<template>
  <div style="position: relative" v-loading="isLoadingDefaultRoute" element-loading-text="加载中请稍后...">
    <div id="map-container" ref="mapContainer"></div>
    <div class="takeoff-point" v-if="drawing_mode == 1">
      点击地图设置起飞点
    </div>
    <div class="tips">
      <p style="display: flex; align-items: center">
        点击图标
        <RouteIcon name="draw" width="18" />
        进行绘制/取消绘制航线
      </p>
      <p>ALT加左键拖动调整航点高度</p>
      <p>鼠标右键删除航点/航线</p>
      <p>鼠标左键拖动底部坐标调整位置</p>
    </div>
    <!-- 删除按钮 -->
    <div v-if="showDeleteButton" class="delete-button delete-confirm-btn" @click.stop @mousedown.stop :style="{
      left: deleteButtonPosition.x + 'px',
      top: deleteButtonPosition.y + 'px',
    }">
      <p @click.stop="deleteWaypoint" style="padding: 0 4px; font-size: 12px">
        删除
      </p>
    </div>

    <linemap ref="mapviewRef" :rotation="rotation" :previousPitch="previousPitch" :drawing_mode="drawing_mode"
      @viewClick="getviewClick" @mapsizeClick="getmapsizeClick" @mouseDrawClick="getmouseDrawClickright"
      @viewsetRotationClick="viewsetRotationClick" @viewcenterClick="getviewcenterClick" @mapTypeClick="getmapTypeClick"
      @getsearchClick="getsearchClick" @clearClick="clearClick" @selectItem="getselectItem"></linemap>
    <!-- <flaymap></flaymap> -->
  </div>
</template>
<script type="text/javascript">
// 必须在AMap JS加载前设置安全配置
window._AMapSecurityConfig = {
  securityJsCode: mapSetting.mapSecurity || "",
};
</script>
<script setup>
import {
  ref,
  watch,
  onMounted,
  onBeforeUnmount,
  defineProps,
  computed,
  onUnmounted,
  nextTick,
  toRef,
  reactive
} from "vue";
import { useRoute } from "vue-router";
import AMapLoader from "@amap/amap-jsapi-loader";
import { ElIcon, ElInput, ElSelect, ElButton, ElMessage } from "element-plus";
import linemap from "./linemap.vue";
// import flaymap from "./flaymap.vue";
import RouteIcon from "./iocn.vue";
import "./mapdata.css";
import { mapSetting } from "#/api/map";
const mapviewRef = ref();
const geocoder = ref(null); // 地理编码器实例
const tipInput = ref(""); // 检索关键字 搜索用的
const autoComplete = ref(null);
const placeSearch = ref(null);
const address = ref();
const searchMarkers = ref([]);
const point = ref([]);
const props = defineProps({
  // flayShow: Boolean,
  // flayoneShow: Boolean,
  form: {
    type: Object,
    default: {
      id: "",
      airlineName: "", // 航线名称，从路由参数获取
      airlineType: 0,//航线类型 0.点状航线，1.线状航线
      wideType: 1,//0支持广角照片 1.不支持广角照片(暂时写死，通过机型接口获取，接口没传)
      zoomType: 1,//0支持变焦照片 1不支持变焦照片(暂时写死，通过机型接口获取，接口没传)
      airlineHeightType: 0, //航线高度模式  0相对起飞点高度 1相对地面高度 2绝对高度
      globalHeight: 100, //飞行高度
      autoFlightSpeed: 10, //飞行速度
      globalTransitionalSpeed: 10, //起飞速度
      attitudeHead: 0, //偏航角 0沿航线方向 1手动控制 2锁定当前偏航角
      wayPointType: 1, //航点类型
      // 0. 协调转弯，不过点，提前转弯 1. 直线飞行，飞行器点到停 2. 平滑过点，提前转弯 3. 曲线飞行，飞行器到点停 4. 曲线飞行，飞行器过点不停
      outOfControlAction: 0, //无人机失控 0自动返航 1返回航线到起始点悬停 2退出航线模式 3原地降落
      finishAction: 0, //无人机完成动作 0自动返航 1返回航线到起始点悬停 2退出航线模式 3原地降落
      takeOffSecurityHeight: 120, //安全起飞高度
      globalRTHHeight: 120, //全局返航高度
      pointNum: 0, //航点数
      totalDistance: 0, //总距离
      executeTime: '', //执行时间
      wayPoints: [],
      irType: 0, //红外照片// 0代表选中，1代表未选中
      visableType: 0, //可见光照片// 0代表选中，1代表未选中
      takeOffRefPoint: ''//起飞点经纬度用,分割
    }
  },
  flightaltitude: {
    type: Number,
    default: 120, // 默认海拔高度
  },
  drawDefaultRoute: {
    type: Array,
    default: () => [], // 默认航线数据
  },
  safetakeoffaltitude: {
    type: Number,
    default: 120, // 默认起飞高度
  },
  // airlineList: {
  //   type: Array,
  //   default: () => [], // 更新各个航点高度
  // },
  selectedWayPoint: {
    type: Object,
    default: () => { }, // 选中航点
  },
  airportList: {
    type: Array,
    default: () => [], // 机场列表
  },
  // airlineform: {
  //   type: Object,
  //   default: () => {}, // 航线表单
  // },//
});
const emit = defineEmits([
  "delSetTakeoffMode",
  "allData",
  "startdata",
  "totalDistance",
  "distanceArray",
  "waypointCoordinateUpdated", // 新增：航点坐标更新事件
  "updateSearchInfo",
  "waypointDoubleClick", // 新增：航点双击事件
  "drawingnext", // 新增：绘制航线状态
]);
// 获取路由参数
const route = useRoute();
const map = ref(null); // 地图实例
const loca = ref(null); // 实例
const mapContainer = ref(null); //地图元素ref (一次性)
const defaultCenter = [119.904953, 30.251849]; // 在组件顶部定义默认中心点
const previousPitch = ref(0); // 跟踪之前的pitch值 //用于地图3d/2d视角
const isMapInitialized = ref(false); // 地图是否已初始化完成
// const hasUserInteracted = ref(false); // 用户是否已经进行过任何操作
const isFirstTimeTakeoff = ref(true); // 是否是首次设置起飞点
const isResetMode = ref(false); // 是否处于重设模式
// const isExitingFirstTimeMode = ref(false); // 是否正在退出首次设置模式
const isLoadingDefaultRoute = ref(false); // 是否正在加载默认航线
const airportLists = ref(props.airportList ? props.airportList : []); //机场列表
const pointsList = ref([]);
const lineData = ref([]);
const guideLineData = ref([]);
const distanceArray = ref([]); //距离数组
const bottomPoints = ref([]); //底部坐标
// 删除按钮相关
const showDeleteButton = ref(false);
const deleteButtonPosition = ref({ x: 0, y: 0 });
const selectedWaypointIndex = ref(0);// 选中
// 距离计算相关
const totalDistance = ref(0); // 总距离（米）
// 新增状态变量
const isAltPressed = ref(false);
const isDraggingHeight = ref(false);
const startDragY = ref(0);
const originalHeight = ref(0);
const currentDraggingMarker = ref(null);
let defaultHeight = 200; // 默认高度
// const isDrawing = ref(false); // 是否正在绘制
const offset = 0; // 约1米偏移，确保线段可见
const drawing_mode = ref(1); // 绘制模式 1起飞点绘制 2航线绘制 3不绘制
const is_has_takeOffRefPoint = ref(false); // 是否有起飞点(为了方便显示)

const previousHeightMode = ref(300); // 跟踪之前的高度模式

const satelliteLayer = ref(null);
const roadNetLayer = ref(null);
// 修复图层相关变量定义
let AMap = null; // 全局AMap引用
const allData = ref({// 航线航点
  lineData: [],//航线
  guideLineData: [],//航点辅助线
  points: [],//航点 经度，纬度，高度
  markers: [],//航点marker
  groundMarkers: [],//航点地面marker
  distanceMarkers: []//距离标签marker
});
// 起飞点
const startdata = ref({
  lineData: {},
  guideLineData: {},
  point: [],
  marker: ''
});
// 初始化地图
const initMap = async () => {
  try {
    // 第一步：加载基础AMap
    AMap = await AMapLoader.load({
      key: mapSetting.mapKey,
      version: "2.0",
      plugins: [
        "AMap.PlaceSearch",
        "AMap.Geocoder",
        "AMap.AutoComplete",
        "AMap.ToolBar",
        "AMap.Scale",
        "AMap.Marker",
        "AMap.Geolocation",
        "AMap.Polyline",
        "AMap.BasicControl",
        "AMap.GetRotation",
        "AMap.ControlBar",
        "AMap.SetPitch",
        "AMap.Circle",
      ],
      features: ["bg", "building", "road"],
    });
    // 创建地图实例
    map.value = new AMap.Map(mapContainer.value, {
      zoom: 18,
      center: defaultCenter, //默认中心点
      viewMode: "3D",
      pitch: 50,
      rotateEnable: true, // 启用旋转
      dragEnable: true, // 启用拖拽
      zoomEnable: true, // 启用缩放
      doubleClickZoom: false, // 禁用双击放大，防止在设置起飞点时意外放大地图
      // layers: layers.value,
    });
    // map.value.addControl(new AMap.ControlBar({
    //   position: {
    //     right: 'calc(17.5% - 12px)',
    //     bottom: '231px'
    //   },
    //   showControlButton: false,  // 是否显示倾斜、旋转按钮。默认为 true
    // }));
    satelliteLayer.value = new AMap.TileLayer.Satellite();
    roadNetLayer.value = new AMap.TileLayer.RoadNet();
    //批量添加图层
    map.value.add([satelliteLayer.value, roadNetLayer.value]);
    if (!window.Loca) {
      await new Promise((resolve, reject) => {
        const script = document.createElement("script");
        script.src =
          "https://webapi.amap.com/loca?v=2.0&key=" + mapSetting.mapKey;
        script.onload = resolve;
        script.onerror = reject;
        document.head.appendChild(script);
      });
    }
    // 2. 用 window.Loca 创建实例
    loca.value = new window.Loca.Container({ map: map.value });
    // 绘制线段初始化
    flayLine(loca.value);

    // 初始化地理编码器
    if (AMap && AMap.Geocoder) {
      geocoder.value = new AMap.Geocoder({
        city: "010", //城市设为北京，默认："全国"
        radius: 1000, //范围，默认：500
      });
    }
    // 搜索框自动完成类
    if (AMap && AMap.AutoComplete) {
      autoComplete.value = new AMap.AutoComplete({
        input: "keyword", // input 为绑定输入提示功能的input的DOM ID
      });
    }
    // 构造地点查询类
    if (AMap && AMap.PlaceSearch) {
      placeSearch.value = new AMap.PlaceSearch({
        map: map.value,
        autoFitView: false,
        map: null
      });
    }
    // 创建机场标记
    if (airportLists.value.length > 0) {
      createAirportMarker();
    }
    bindMapEvents(); // 绑定地图事件
    // 添加旋转事件监听
    initRotationListeners();
    // 添加键盘和鼠标事件监听
    window.addEventListener("keydown", handleKeyDown);
    window.addEventListener("keyup", handleKeyUp);
    document.addEventListener('visibilitychange', hvisibilitychange);
    window.addEventListener('blur', hvisibilityblur);
    // window.addEventListener('focus', hvisibilityfocus);
    map.value.on("mousemove", get_mousemove)
    map.value.on("mouseup", () => {
      isDraggingHeight.value = false;
    });
    // 初始化zoom监听器，设置辅助线粗细
    zoomChange();
    // 设置地图初始化完成标志
    isMapInitialized.value = true;
    // 如果输入框已经有值，初始化时触发一次搜索
    // if (tipInput.value && placeSearch.value) {
    //   placeSearch.value.search(tipInput.value);
    // }
  } catch (error) {
    console.error("地图初始化失败:", error);
  }
};
const hvisibilityblur = () => {
  map.value.setStatus({
    dragEnable: true
  });
  isAltPressed.value = false;
  if (map.value) {
    map.value.getContainer().style.cursor = drawing_mode.value != 3
      ? "crosshair"
      : "default";
  }
  // 结束高度拖动
  endHeightDrag();
}
const hvisibilitychange = () => {
  if (document.visibilityState == 'hidden') {
    map.value.setStatus({
      dragEnable: true
    });
    isAltPressed.value = false;
    if (map.value) {
      map.value.getContainer().style.cursor = drawing_mode.value != 3
        ? "crosshair"
        : "default";
    }
    // 结束高度拖动
    endHeightDrag();
  }
}
// 创建机场标记
const createAirportMarker = () => {
  if (!map.value) return;
  // 先清除已存在的机场标记
  if (window.airportMarkers && window.airportMarkers.length > 0) {
    window.airportMarkers.forEach((marker) => {
      map.value.remove(marker);
    });
  }
  window.airportMarkers = []; // 存储机场标记的全局变量
  try {
    airportLists.value.forEach((airport) => {
      // 验证机场数据
      if (!airport.longitude || !airport.latitude) {
        console.warn("机场数据缺少经纬度信息:", airport);
        return;
      }
      const marker = new AMap.Marker({
        position: [airport.longitude, airport.latitude],
        content: `<div class="airport-marker">
              <img src="/static/blueairport.png" width="40" height="40" style="display: block;" />
              <p style="margin: 2px 0 0 0; line-height: 1;">${airport.airportName}</p>
           </div>`,
        offset: new AMap.Pixel(-20, -30),
        zIndex: 0,
      });

      map.value.add(marker);
      window.airportMarkers.push(marker); // 保存引用以便后续清除
    });
    map.value.setFitView();
  } catch (error) {
    console.error("创建机场图标时出错:", error);
  }
};
// 设置浮空线段
const flayLine = (locaInstance) => {
  if (window.Loca && locaInstance) {
    try {
      // 创建 LineLayer（浮空线段）
      const lineLayer = new window.Loca.LineLayer({
        zIndex: 100, // 确保图层在上层
      });

      // 创建辅助线图层
      const guideLineLayer = new window.Loca.LaserLayer({
        zIndex: 55, // 确保辅助线在底层但可见
        zooms: [2, 20], //
      });

      // 设置 LineLayer 数据源
      lineLayer.setSource(
        new window.Loca.GeoJSONSource({
          data: {
            type: "FeatureCollection",
            features: [],
          },
        })
      );

      // 设置辅助线图层数据源
      guideLineLayer.setSource(
        new window.Loca.GeoJSONSource({
          data: {
            type: "FeatureCollection",
            features: [],
          },
        })
      );

      // 设置辅助线样式 - 使用静态线条
      guideLineLayer.setStyle({
        altitude: true, // 启用高度
        lineWidth: 3, // 线条宽度
        color: "#f0ed7a", // 黄色辅助线
      });

      // 设置 LineLayer 样式 浮空线段样式
      lineLayer.setStyle({
        altitude: true, // 启用高度
        lineWidth: 5, // 线段宽度
        color: "#00d58f", // 颜色属性名改为 color
      });

      // 将图层添加到loca容器
      locaInstance.add(lineLayer);
      locaInstance.add(guideLineLayer);

      // 保存图层引用到全局变量
      window.lineLayer = lineLayer;
      window.guideLineLayer = guideLineLayer;

      // 启动激光线动画
      if (locaInstance && locaInstance.animate) {
        locaInstance.animate.start();
      }
    } catch (error) {
      console.error("flayLine 创建图层时出错:", error);
    }
  } else {
    console.error("flayLine 条件不满足:");
    console.error("window.Loca:", window.Loca);
    console.error("locaInstance:", locaInstance);
  }
};
// 绑定地图事件
const bindMapEvents = (val) => {
  // 添加鼠标按下事件，如果鼠标不在删除按钮上就隐藏删除按钮
  map.value.on("mousedown", (e) => {
    // 检查鼠标按下是否在删除按钮上
    const target = e.originalEvent?.target;
    if (target && !target.closest(".delete-button")) {
      hideDeleteButton();
    }
  });
  // 阻止地图容器的默认右键菜单
  map.value.getContainer().addEventListener("contextmenu", (e) => {
    e.preventDefault();
  });
  map.value.on("click", function (ev) {
    // 检查点击是否在删除按钮上
    hideDeleteButton();
    // const target = ev.originEvent?.target;
    // if (target && !target.closest(".delete-button")) {
    //   hideDeleteButton();
    // }
    map_click(ev)
  });
};
// 点击右边开始画航线按钮
const getmouseDrawClickright = (val) => {
  if (val) {
    drawing_mode.value = 2
  } else {
    drawing_mode.value = 3
  }
  getmouseDrawClick()
}

// 地图的点击事件
const map_click = (ev) => {
  var lnglat = lnglatToNumber(ev.lnglat.KL, ev.lnglat.kT);
  // const point = [lnglat[0], lnglat[1], defaultHeight]; //空中点坐标，限制精度
  if (drawing_mode.value == 1) {
    // 绘制起飞点模式
    handleMapClickForTakeoff(lnglat);
    is_has_takeOffRefPoint.value = true;
  } else if (drawing_mode.value == 2) {
    // 绘制航线模式
    click_to_addLine(lnglat);
  }
  // 给父级更新起飞点状态
  getmouseDrawClick()
}
// 在地图上点击设置起飞点
const handleMapClickForTakeoff = (lnglat, hhhh, is_render = true) => {
  // 在起飞点绘制模式下才执行
  if (drawing_mode.value != 1) return;
  drawing_mode.value = 3
  const defaultHeight = hhhh || props.safetakeoffaltitude || 200; // 使用安全起飞高度
  const takeoffPosition = [lnglat[0], lnglat[1], defaultHeight];
  startdata.value.point = takeoffPosition
  // 清除现有的起飞点
  if (startdata.value.marker) {
    map.value.remove(startdata.value.marker);
    startdata.value.marker = null;
  }
  // 创建起飞点标记
  const t_extData = {
    altitude: 0, // 起飞点标记保持在地面
    index: -1,
    originalPosition: [lnglat[0], lnglat[1]],
  }
  const takeoffMarker = new AMap.Marker({
    position: [lnglat[0], lnglat[1]],
    content: `<div style="display:flex;align-items:center;justify-content:center;width:30px;height:30px;font-weight:bold;color:white;background:#fff;border-radius:50%;"><img style="width:30px;height:30px" src="/static/flay.png" /></div>`,
    offset: new AMap.Pixel(-15, -15),
    extData: t_extData,
    draggable: true,
  });
  map.value.add(takeoffMarker);
  startdata.value.marker = takeoffMarker
  // 渲染高度
  render_marker_height(takeoffMarker);
  // 添加起飞点鼠标悬停事件 - 显示拖动光标
  takeoffMarker.on("mouseover", (e) => {
    if (map.value) {
      map.value.getContainer().style.cursor = "move";
    }
  });

  takeoffMarker.on("mouseout", (e) => {
    if (map.value) {
      // 恢复默认光标样式
      if (drawing_mode.value != 3) {
        map.value.getContainer().style.cursor = "crosshair";
      } else {
        map.value.getContainer().style.cursor = "default"
      }
    }
  });

  // 添加起飞点拖动事件
  takeoffMarker.on("dragstart", (e) => {
    // 拖动开始时设置光标为move
    if (map.value) {
      map.value.getContainer().style.cursor = "move";
    }
  });

  takeoffMarker.on("dragging", (e) => {
    const extData = takeoffMarker.getExtData();
    const newPosition = lnglatToNumber(e.lnglat.KL, e.lnglat.kT);
    // 起飞点只支持正常拖动，不支持高度调整
    extData.originalPosition = [newPosition[0], newPosition[1]];
    takeoffMarker.setExtData(extData);

    // 使用安全起飞高度，而不是extData.altitude
    const takeoffHeight = startdata.value.point[2] || props.safetakeoffaltitude || 300;
    startdata.value.point = [
      newPosition[0],
      newPosition[1],
      takeoffHeight,
    ];
    // 更新线段和辅助线
    updateLineAndGuideLine(
      startdata.value.point,
      extData
    );
    RenderinglineLayer();
    RenderingguideLineLayer();
  });

  takeoffMarker.on("dragend", (e) => {
    // 拖动结束时恢复光标样式
    emit("startdata", startdata.value);
    emit("totalDistance", totalDistance.value);
    // if (map.value) {
    //   if (drawing_mode.value != 3) {
    //     map.value.getContainer().style.cursor = "crosshair";
    //   } else {
    //     map.value.getContainer().style.cursor = "default"
    //   }
    // }
    // 使用防抖发送数据更新事件
    // debouncedEmitAllData();
    // debouncedEmitTotalDistance(totalDistance.value);
  });
  updateLineAndGuideLine(
    [lnglat[0], lnglat[1], defaultHeight],
    t_extData
  );
  if (is_render) {
    // 重新渲染图层
    RenderinglineLayer();
    RenderingguideLineLayer();
    // 更新距离标签
    updateDistanceLabels();
    // 重新计算总距离
    calculateTotalDistance();
    emit("startdata", startdata.value);
    emit("totalDistance", totalDistance.value);
  }
};
// 在地图上点击设置添加航点
const click_to_addLine = (lnglat) => {
  if (drawing_mode.value != 2) return;
  const defaultHeight = (!props.form?.globalHeight && props.form?.globalHeight !== 0) ? 200 : props.form?.globalHeight; // 使用安全起飞高度
  const takeoffPosition = [lnglat[0], lnglat[1], defaultHeight];
  const index = allData.value.points.length
  allData.value.points.push(takeoffPosition)
  addMarker(takeoffPosition, index);
}
// 根据默认数据绘制航线
// const drawDefaultRoute = (defaultData) => {

//   // hasUserInteracted.value = true; // 标记用户已进行交互（加载默认数据）
//   if (!map.value || !AMap) {
//     console.error("地图未初始化");
//     return;
//   }
//   // 确保有默认数据
//   if (!defaultData) {
//     console.error("默认数据格式错误");
//     return;
//   }

//   // 初始化航线数据结构
//   allData.value = [
//     {
//       name: "默认航线",
//       // startdata: {
//       //   lineData: null,
//       //   guideLineData: null,
//       //   point: [],
//       //   marker: null,
//       // },
//       lineData: [],
//       guideLineData: [],
//       points: [],
//       markers: [],
//     },
//   ];

//   // 处理起飞点
//   if (defaultData.startdata && defaultData.startdata.point) {
//     const takeoffPoint = defaultData.startdata.point;
//     startdata.point = takeoffPoint;
//     // 如果有默认起飞点，标记不是首次设置
//     isFirstTimeTakeoff.value = false;

//     // 创建起飞点标记
//     const takeoffMarker = new AMap.Marker({
//       position: [takeoffPoint[0], takeoffPoint[1]],
//       content: `<div style="display:flex;align-items:center;justify-content:center;width:30px;height:30px;font-weight:bold;color:white;background:#fff;border-radius:50%;"><img src="/static/flay.png" width="24" height="24" /></div>`,
//       offset: new AMap.Pixel(-20, -20),
//       extData: {
//         altitude: 0, // 起飞点标记保持在地面
//         index: -1,
//         originalPosition: [takeoffPoint[0], takeoffPoint[1]],
//       },
//       draggable: true, // 允许起飞点拖动
//     });

//     map.value.add(takeoffMarker);
//     render_marker_height(takeoffMarker);
//     startdata.marker = takeoffMarker;

//     // 保存起飞点的原始位置，用于后续保护
//     const originalTakeoffPosition = [takeoffPoint[0], takeoffPoint[1]];
//     window.originalTakeoffPosition = originalTakeoffPosition;

//     // 创建起飞点辅助线 - 改为Point类型
//     if (takeoffPoint && takeoffPoint.length >= 3) {
//       startdata.guideLineData = {
//         type: "Feature",
//         geometry: {
//           type: "Point",
//           coordinates: [
//             arithmetic.subtract(takeoffPoint[0], offset),
//             takeoffPoint[1],
//           ], // 地面点坐标
//         },
//         properties: {
//           color: "#00d58f",
//           isStartGuideLine: true,
//           h: takeoffPoint[2], // 使用h属性，与mapvvvv.html保持一致
//         },
//       };
//     }

//     // 添加起飞点鼠标悬停事件 - 显示拖动光标
//     takeoffMarker.on("mouseover", (e) => {
//       if (map.value) {
//         map.value.getContainer().style.cursor = "move";
//       }
//     });

//     takeoffMarker.on("mouseout", (e) => {
//       if (map.value) {
//         // 恢复默认光标样式
//         if (drawing_mode.value == 1) {
//           map.value.getContainer().style.cursor = "crosshair";
//         } else {
//           map.value.getContainer().style.cursor = drawing_mode.value != 3
//             ? "crosshair"
//             : "default";
//         }
//       }
//     });

//     // 添加起飞点拖动事件
//     takeoffMarker.on("dragstart", (e) => {
//       // 拖动开始时设置光标为move
//       if (map.value) {
//         map.value.getContainer().style.cursor = "move";
//       }
//     });

//     takeoffMarker.on("dragging", (e) => {
//       const extData = takeoffMarker.getExtData();
//       const newPosition = lnglatToNumber(e.lnglat.KL, e.lnglat.kT);

//       // 起飞点只支持正常拖动，不支持高度调整
//       extData.originalPosition = [newPosition[0], newPosition[1]];
//       takeoffMarker.setExtData(extData);

//       // 使用安全起飞高度，而不是extData.altitude
//       const takeoffHeight =
//         props.safetakeoffaltitude || startdata.point[2] || 300;

//       startdata.point = [
//         newPosition[0],
//         newPosition[1],
//         takeoffHeight,
//       ];

//       updateLineAndGuideLine(
//         [newPosition[0], newPosition[1], takeoffHeight],
//         extData
//       );
//     });

//     takeoffMarker.on("dragend", (e) => {
//       // 拖动结束时恢复光标样式
//       if (map.value) {
//         if (drawing_mode.value != 3) {
//           map.value.getContainer().style.cursor = "crosshair";
//         } else {
//           map.value.getContainer().style.cursor = "default";
//         }
//       }
//     });
//   }

//   // 处理航点 - 支持多种数据格式
//   let waypoints = [];
//   if (defaultData.points && Array.isArray(defaultData.points)) {
//     waypoints = defaultData.points;
//   } else if (defaultData.point && Array.isArray(defaultData.point)) {
//     // 如果数据格式是 point 数组
//     waypoints = defaultData.point;
//   }

//   if (waypoints.length > 0) {
//     waypoints.forEach((point, index) => {
//       // 确保点数据格式正确 [lng, lat, height]
//       const waypoint = Array.isArray(point)
//         ? point
//         : [
//           point.lng || point[0],
//           point.lat || point[1],
//           point.height || point[2] || defaultHeight,
//         ];

//       // 添加航点标记
//       const marker = new AMap.Marker({
//         position: [waypoint[0], waypoint[1]],
//         content: `<div style="position:relative;">
//           <div class="line-tooltip">
//             <div>ASL: ${waypoint[2]}m</div>
//             <div>HAE: ${waypoint[2]}m</div>
//           </div>
//           <div class="marker-index">${index + 1}</div>
//         </div>`,
//         offset: new AMap.Pixel(-15, -15),
//         extData: {
//           altitude: waypoint[2],
//           index: index,
//           originalPosition: [waypoint[0], waypoint[1]],
//         },
//         draggable: true, // 空中航点拖动
//       });

//       map.value.add(marker);

//       // 在2D模式下隐藏空中航点
//       if (previousPitch.value == 0) {
//         marker.hide();
//       }

//       render_marker_height(marker);
//       addMarkerTooltip(marker, "航点");

//       // 添加单击事件（右键删除）
//       marker.on("click", (e) => {
//         const originalEvent = e.originalEvent || e;
//         if (originalEvent.button === 2) {
//           showDeleteButtonHandler(originalEvent, index);
//           originalEvent.preventDefault();
//           return;
//         }
//       });

//       // 添加双击事件 - 使用AMap原生的dblclick事件
//       marker.on("dblclick", (e) => {
//         // 双击事件 - 将航点数据传给父元素
//         const position = marker.getPosition();
//         const extData = marker.getExtData();
//         const waypointData = {
//           lng: position.lng,
//           lat: position.lat,
//           altitude: extData.altitude || 0,
//           index: extData.index,
//         };

//         // 发送给父组件
//         emit("waypointDoubleClick", waypointData);
//       });

//       marker.on("rightclick", (e) => {
//         showDeleteButtonHandler(e, index);
//       });

//       marker.on("contextmenu", (e) => {
//         if (e.originalEvent) {
//           e.originalEvent.preventDefault();
//         }
//       });
//       // 添加拖动事件
//       marker.on("dragging", (e) => {
//         const extData = marker.getExtData();
//         const newPosition = lnglatToNumber(e.lnglat.KL, e.lnglat.kT);

//         // 空中航点只有在按下Alt键时才允许拖动
//         if (!isAltPressed.value) {
//           // 如果没有按Alt键，阻止拖动，回到原位置
//           marker.setPosition([
//             extData.originalPosition[0],
//             extData.originalPosition[1],
//             extData.altitude,
//           ]);
//           return;
//         }

//         if (isAltPressed.value && isDraggingHeight.value) {
//           // 高度调整模式
//           const heightChange = (startDragY.value - e.pixel.y) * 0.5;
//           const newHeight = Math.max(0, originalHeight.value + heightChange);

//           extData.altitude = newHeight;
//           marker.setExtData(extData);

//           marker.setPosition([
//             extData.originalPosition[0],
//             extData.originalPosition[1],
//             newHeight,
//           ]);
//           render_marker_height(marker);

//           // 更新 points 数组
//           allData.value.points[index] = [
//             extData.originalPosition[0],
//             extData.originalPosition[1],
//             newHeight,
//           ];

//           updateLineAndGuideLine(
//             [
//               extData.originalPosition[0],
//               extData.originalPosition[1],
//               newHeight,
//             ],
//             extData
//           );
//         } else if (isAltPressed.value) {
//           // 正常拖动模式 - 只有按下Alt键时才允许
//           extData.originalPosition = [newPosition[0], newPosition[1]];
//           marker.setExtData({
//             ...extData,
//             altitude: newPosition[2] || extData.altitude,
//           });

//           allData.value.points[index] = [
//             newPosition.lng,
//             newPosition.lat,
//             extData.altitude,
//           ];

//           updateMarker(
//             [newPosition.lng, newPosition.lat, extData.altitude],
//             extData
//           );
//           updateLineAndGuideLine(
//             [newPosition.lng, newPosition.lat, extData.altitude],
//             extData
//           );
//         }
//       });

//       // 添加鼠标事件
//       marker.on("mousedown", (e) => {
//         const originalEvent = e.originalEvent || e.originEvent || e;
//         if (isAltPressed.value && originalEvent && originalEvent.button === 0) {
//           startHeightDrag(marker, originalEvent.clientY);
//         }
//       });

//       marker.on("mouseup", () => {
//         if (isDraggingHeight.value) {
//           endHeightDrag();
//         }
//       });

//       // 添加到数组
//       allData.value.markers.push(marker);
//       allData.value.points.push(waypoint);

//       // 创建航点辅助线 - 改为Point类型
//       if (waypoint && waypoint.length >= 3) {
//         allData.value.guideLineData.push({
//           type: "Feature",
//           geometry: {
//             type: "Point",
//             coordinates: [
//               arithmetic.subtract(waypoint[0], offset),
//               waypoint[1],
//             ], // 地面点坐标
//           },
//           properties: {
//             color: "#f4ed7c",
//             h: waypoint[2], // 使用h属性，与mapvvvv.html保持一致
//           },
//         });
//       }
//     });

//     for (let i = 0; i < allData.value.points.length - 1; i++) {
//       const start = allData.value.points[i];
//       const end = allData.value.points[i + 1];
//       const segmentDistance = calculateDistance(start, end);

//       allData.value.lineData.push({
//         type: "Feature",
//         geometry: {
//           type: "LineString",
//           coordinates: [
//             [start[0], start[1], start[2]],
//             [end[0], end[1], end[2]],
//           ],
//         },
//         properties: {
//           color: "#3366ff",
//           distance: segmentDistance,
//         },
//       });
//     }

//     // 如果有起飞点和航点，创建起飞点连接线
//     if (
//       startdata.point &&
//       startdata.point.length > 0 &&
//       allData.value.points.length > 0
//     ) {
//       const startPoint = startdata.point;
//       const firstWaypoint = allData.value.points[0];
//       const segmentDistance = calculateDistance(startPoint, firstWaypoint);

//       startdata.lineData = {
//         type: "Feature",
//         geometry: {
//           type: "LineString",
//           coordinates: [startPoint, firstWaypoint],
//         },
//         properties: {
//           color: "#3366ff",
//           distance: segmentDistance,
//         },
//       };
//     }
//   }

//   // 重新渲染图层
//   RenderinglineLayer();
//   RenderingguideLineLayer();

//   // 更新距离标签
//   updateDistanceLabels();

//   // 重新计算总距离
//   calculateTotalDistance();

//   // 通知父组件数据更新
//   // console.log("更新数据1", allData.value);
//   emit("allData", allData.value);
//   emit("totalDistance", totalDistance.value);

//   // 将地图中心点设置为起飞点位置
//   if (
//     startdata.point &&
//     startdata.point.length > 0
//   ) {
//     const takeoffPoint = startdata.point;

//     map.value.setCenter([takeoffPoint[0], takeoffPoint[1]]);
//     map.value.setZoom(16); // 设置合适的缩放级别
//   }

//   // 设置绘制模式为不绘制模式
//   drawing_mode.value = 3; // 设置为不绘制模式
//   // isDrawing.value = false; // 不自动启用绘制状态，让用户手动控制
//   map.value.getContainer().style.cursor = "default"; // 不自动设置鼠标样式

//   // 渲染底部小圆点
//   RenderingpointLayer();
//   // 清除加载状态
//   isLoadingDefaultRoute.value = false;

//   // 绘制完成后使用防抖发送数据更新事件
//   nextTick(() => {
//     debouncedEmitAllData();
//     debouncedEmitTotalDistance(totalDistance.value);

//     // 绘制完成后检查是否需要显示起飞点提示
//     if (shouldShowTakeoffTip.value && map.value) {
//       // isDrawing.value = true;
//       drawing_mode.value = 1; // 起飞点设置模式
//       map.value.getContainer().style.cursor = "crosshair";

//       // 确保添加起飞点点击监听器
//       // map.value.off("click", handleMapClickForTakeoff);
//       // map.value.on("click", handleMapClickForTakeoff);
//     }
//   });
// };
// 添加zoom监听器 设置辅助线样式
const zoomChange = () => {
  map.value.on("zoomend", function () {
    const currentZoom = map.value.getZoom();
    let newLineWidth;
    // 根据zoom级别设置线条粗细，zoom越大线条越细
    if (currentZoom >= 19.5) {
      newLineWidth = 0.7; // 最高级别，最细线条
    } else if (currentZoom >= 19) {
      newLineWidth = 1.0;
    } else if (currentZoom >= 18.5) {
      newLineWidth = 1.2;
    } else if (currentZoom >= 18) {
      newLineWidth = 1.6;
    } else if (currentZoom >= 17.5) {
      newLineWidth = 2.0;
    } else if (currentZoom >= 17) {
      newLineWidth = 3.0;
    } else if (currentZoom >= 16.5) {
      newLineWidth = 4.0;
    } else if (currentZoom >= 16) {
      newLineWidth = 6.0;
    } else {
      newLineWidth = 7.0; // 最低级别，最粗线条
    }
    // 重新设置辅助线样式 - 使用全局的 guideLineLayer
    if (window.guideLineLayer && allData.value.guideLineData.length > 0 || startdata.value.guideLineData.type) {
      // 获取辅助线数据
      let arr = [];
      if (Array.isArray(allData.value.guideLineData)) {
        arr = arr.concat(...allData.value.guideLineData);
      }
      if (startdata.value?.guideLineData?.type) {
        arr.push(startdata.value.guideLineData);
      }

      // 重新设置数据源，保持静态辅助线效果并更新线条宽度
      window.guideLineLayer.setSource(
        new window.Loca.GeoJSONSource({
          data: {
            type: "FeatureCollection",
            features: arr,
          },
        }),
        {
          unit: "meter",
          height: (index, feature) => {
            return feature.properties.h || 0;
          },
          color: "#f0ed7a", // 黄色辅助线
          lineWidth: newLineWidth, // 使用新的线条宽度
          trailLength: 50000, // 设置为0，禁用流动效果
          repeat: 0, // 不重复
        }
      );
      // 重新渲染以应用新样式
      window.guideLineLayer.render();
    }
  });
};
// 计算两点之间的距离（米）新
const computeDis = (p1, p2) => {
  let a1 = new AMap.LngLat(p1[0], p1[1]);
  let a2 = new AMap.LngLat(p2[0], p2[1]);
  return Math.round(a1.distance(a2))
}
// 计算两点之间的距离（米）
const calculateDistance = (point1, point2) => {
  // 计算3D空间的实际距离，包括高度差
  if (!point2) return 0
  const lnglat1 = new AMap.LngLat(point1[0], point1[1]);
  const lnglat2 = new AMap.LngLat(point2[0], point2[1]);
  const horizontalDistance = lnglat1.distance(lnglat2); // 水平距离
  const heightDiff = Math.abs((point1[2] || 0) - (point2[2] || 0)); // 计算高度差
  const distance = Math.sqrt(
    horizontalDistance * horizontalDistance + heightDiff * heightDiff
  );
  return Math.round(distance); // 四舍五入到整数
};
// 计算总距离ZZZz
const calculateTotalDistance = () => {
  if (allData.value.length === 0) {
    totalDistance.value = 0;
    distanceArray.value = []; // 清空距离数组
    return;
  }
  let distance = 0;
  const newDistanceArray = []; // 临时数组存储所有距离
  const avdata = allData.value;
  // 计算起飞点高度变化的距离（从地面到起飞点高度）
  // if (avdata.startdata?.point && avdata.startdata.point.length > 0) {
  //   const takeoffHeight = avdata.startdata.point[2] || 0;
  //   distance += takeoffHeight; // 起飞点高度变化距离
  //   newDistanceArray.push(takeoffHeight); // 添加到距离数组
  // }
  if (startdata.value.point.length > 0) {
    const takeoffHeight = startdata.value.point[2] || 0;
    distance += takeoffHeight; // 起飞点高度变化距离
    newDistanceArray.push(takeoffHeight); // 添加到距离数组
  }
  // 计算起飞点连接线距离
  if (startdata.value.lineData?.geometry?.coordinates) {
    const [start, end] = startdata.value.lineData.geometry.coordinates;
    const segmentDistance = computeDis(start, end);
    distance += segmentDistance;
    newDistanceArray.push(segmentDistance); // 添加到距离数组
  }
  // 计算航点间线段距离
  if (avdata.lineData && Array.isArray(avdata.lineData)) {
    avdata.lineData.forEach((line, index) => {
      if (line.geometry && line.geometry.coordinates) {
        const [start, end] = line.geometry.coordinates;
        const segmentDistance = computeDis(start, end);
        distance += segmentDistance;
        newDistanceArray.push(segmentDistance); // 添加到距离数组
      }
    });
  }
  totalDistance.value = distance;
  distanceArray.value = newDistanceArray; // 更新距离数组
  // 发送总距离到父组件
  emit("totalDistance", distance);
  // 同时发送距离数组到父组件
  emit("distanceArray", distanceArray.value);
};
const get_mousemove = (e) => {
  // console.log("鼠标移动", e.pixel.y);
  // (startDragY.value - e.pixel.y) * 0.5;
  if (isDraggingHeight.value && isAltPressed.value) {
    // console.log(startDragY.value, originalHeight.value, e.pixel.y)
    const extData = draggingMark_data.value
    let newHeight = 0;
    if (startDragY.value > e.pixel.y) {
      let heightChange = startDragY.value - e.pixel.y;
      newHeight = originalHeight.value + heightChange
    } else {
      let heightChange = e.pixel.y - startDragY.value
      newHeight = originalHeight.value - heightChange
    }
    // const heightChange = (startDragY.value - e.pixel.y);
    // const newHeight = Math.max(0, originalHeight.value + heightChange);
    // const newHeight = (startDragY.value - e.pixel.y) * 1.4;
    // console.log(newHeight)
    // const deltaY = e.pixel.y - startDragY.value;
    // const pitchFactor = Math.cos((previousPitch.value * Math.PI) / 180);
    // const adjustedDelta = deltaY / pitchFactor;
    // const finalHeight = originalHeight.value + adjustedDelta;
    // const deltaY = startDragY.value - e.pixel.y; // 鼠标上移增加高度

    // let wh = map.value.k.height
    // const bl = (wh - e.pixel.y) / (wh - startDragY.value);
    // console.log((wh - e.pixel.y), (wh - startDragY.value))
    // const newHeight = originalHeight.value * bl;

    // 直接应用 deltaY 到初始高度
    // const finalHeight = originalHeight.value + deltaY;
    // 更新高度
    extData.altitude = newHeight;
    // allData.value.markers[extData.index].setExtData(extData);
    // allData.value.points[extData.index] = [extData.originalPosition[0], extData.originalPosition[1], newHeight];
    updateMarker([extData.originalPosition[0], extData.originalPosition[1], newHeight], extData);
    emit("allData", {
      type: 'drag',
      index: extData.index,
      allData: allData.value
    });
    // updateLineAndGuideLine(
    //   [extData.originalPosition[0], extData.originalPosition[1], newHeight],
    //   extData
    // );
  }
}
// 键盘事件处理 高度调整模式
const handleKeyDown = (e) => {
  e.preventDefault();
  // console.log(e.key);
  if (e.key === "Alt") {
    isAltPressed.value = true;
    // 修改鼠标样式为上下箭头，但在重设起飞点模式下保持十字光标
    // for (let i in allData.value.markers) {
    //   allData.value.markers[i].setDraggable(true);
    // }
    map.value.setStatus({
      dragEnable: false
    });

    if (map.value) {
      map.value.getContainer().style.cursor = "ns-resize";
    }
  }
};
// 键盘事件处理 高度调整模式
const handleKeyUp = (e) => {
  // console.log(e.key);
  if (e.key === "Alt") {
    map.value.setStatus({
      dragEnable: true
    });
    isAltPressed.value = false;
    // for (let i in allData.value.markers) {
    //   allData.value.markers[i].setDraggable(false);
    // }
    // 恢复鼠标样式
    if (map.value) {
      map.value.getContainer().style.cursor = drawing_mode.value != 3
        ? "crosshair"
        : "default";
    }
    // 结束高度拖动
    endHeightDrag();
  }
};
// 开始绘制/取消绘制
const getmouseDrawClick = () => {
  // getdrawingNext
  emit("drawingnext", is_has_takeOffRefPoint.value);
  // 开始绘制
  // if (value == true) {
  //   // hasUserInteracted.value = true; // 标记用户已进行交互
  //   // isDrawing.value = true;
  //   map.value.getContainer().style.cursor = "crosshair"; //鼠标样式
  //   // 设置绘制模式为航线绘制
  //   drawing_mode.value = 2;
  // } else {
  //   // 取消绘制
  //   drawing_mode.value = 3;
  //   map.value.getContainer().style.cursor = "default"; //鼠标样式
  // }
};
const draggingMark_data = ref()
// 添加航点(地面/空中)
const addMarker = (position, index, render = true) => {
  var marker = new AMap.Marker({
    position: [position[0], position[1]],
    content: `<div style="position:relative;">
        <div class="line-tooltip">
        <div>ASL: ${position[2]}m</div>
        <div>HAE: ${position[2] + 0}m</div>
      </div>
      <div class="marker-index">${Number(index) + 1}</div> </div>`,
    offset: new AMap.Pixel(-15, -15), // 调整标识位置
    extData: {
      altitude: position[2], // 设置标识的高度
      id: Number(index),
      index: Number(index),
      originalPosition: [position[0], position[1]], // 经纬度
    },
    draggable: false // 空中航点的拖动
  });
  map.value.add(marker);
  // 更新marker高度
  render_marker_height(marker);
  // 添加空中maker
  addMarkerTooltip(marker, "航点");
  // 添加单击事件（右键删除）
  marker.on("click", (e) => {
    const originalEvent = e.originalEvent || e;
    // 检查是否为右键
    if (originalEvent.button === 2) {
      // 右键 显示删除按钮
      showDeleteButtonHandler(originalEvent, index);
      originalEvent.preventDefault();
      return;
    } else {
      // 隐藏删除按钮
      hideDeleteButton()
    }
  });
  // 添加双击事件 - 使用AMap原生的dblclick事件
  marker.on("dblclick", (e) => {
    // 双击事件 - 将航点数据传给父元素
    const position = marker.getPosition();
    const extData = marker.getExtData();
    const waypointData = {
      lng: position.lng,
      lat: position.lat,
      altitude: extData.altitude || 0,
      index: extData.index,
      id: extData.id,
    };
    // 发送给父组件
    emit("waypointDoubleClick", waypointData);
  });
  // 直接监听右键事件
  marker.on("rightclick", (e) => {
    const extData = marker2.getExtData();
    showDeleteButtonHandler(e, extData.index);
  });
  // 阻止默认的右键菜单
  marker.on("contextmenu", (e) => {
    if (e.originalEvent) {
      e.originalEvent.preventDefault();
    }
  });
  // 添加鼠标按下事件
  marker.on("mousedown", (e) => {
    // console.log(e)
    const originalEvent = e.originalEvent || e.originEvent || e;
    draggingMark_data.value = marker.getExtData();
    if (isAltPressed.value) {
      // 左键
      startHeightDrag(marker, originalEvent.clientY);
    }
  });

  // 添加鼠标释放事件
  marker.on("mouseup", () => {
    isDraggingHeight.value = false;
    if (isAltPressed.value) {
      endHeightDrag();
    }
  });
  marker.on("dragging", (e) => {
    // 如果是2D模式才会启用拖动
    const extData = marker.getExtData();
    console.log(extData)
    if (previousPitch.value == 0) {
      const newPosition = lnglatToNumber(e.lnglat.KL, e.lnglat.kT);
      allData.value.points[extData.index] = [...newPosition, allData.value.points[extData.index][2]];
      // 更新地面点
      if (allData.value.groundMarkers[extData.index]) {
        const groundMarker = allData.value.groundMarkers[extData.index];
        const airExtData = groundMarker.getExtData();
        const takeoffPosition = [newPosition[0], newPosition[1], airExtData.altitude];
        airExtData.originalPosition = [newPosition[0], newPosition[1]];
        groundMarker.setExtData({
          altitude: 0, // 高度
          index: airExtData.index,
          originalPosition: newPosition, // 经纬度
        });
        groundMarker.setPosition([
          newPosition[0],
          newPosition[1],
          0,
        ]);
        RenderinglineLayer();
        RenderingguideLineLayer();
        updateLineAndGuideLine(takeoffPosition, airExtData)
        emit("allData", {
          type: 'drag',
          index: extData.index,
          allData: allData.value
        });
        emit("totalDistance", totalDistance.value);
      }
    }
  })
  allData.value.markers.push(marker)

  // 添加地面marker
  var marker2 = new AMap.Marker({
    position: [position[0], position[1]],
    content: `<div style="width:8px;height:8px;background:#f0ed7a;border-radius:50%;border:1px solid #fff;cursor:move;"></div>`,
    offset: new AMap.Pixel(-4, -4), // 调整标识位置
    extData: {
      altitude: 0, // 设置标识的高度
      id: Number(index),
      index: Number(index),
      originalPosition: [position[0], position[1]], // 经纬度
    },
    draggable: true // 禁用地面航点的拖动
  });
  map.value.add(marker2);
  render_marker_height(marker2);
  marker2.on("dragging", (e) => {
    if (previousPitch.value == 0) return;
    const extData = marker2.getExtData();
    const newPosition = lnglatToNumber(e.lnglat.KL, e.lnglat.kT);
    allData.value.points[extData.index] = [...newPosition, allData.value.points[extData.index][2]]
    // 更新起飞点底部标记位置
    marker2.setExtData({
      altitude: extData.altitude, // 高度
      index: extData.index,
      originalPosition: newPosition, // 经纬度
    });
    if (showDeleteButton.value) {
      hideDeleteButton()
    }
    // 更新起飞点空中marker位置和originalPosition经纬度
    if (allData.value.markers[extData.index]) {
      const airMarker = allData.value.markers[extData.index];
      const airExtData = airMarker.getExtData();
      const takeoffPosition = [newPosition[0], newPosition[1], airExtData.altitude]
      airExtData.originalPosition = [newPosition[0], newPosition[1]];
      airMarker.setExtData({
        altitude: airExtData.altitude, // 高度
        index: airExtData.index,
        originalPosition: newPosition, // 经纬度
      });
      airMarker.setPosition([
        newPosition[0],
        newPosition[1],
        airExtData.altitude,
      ]);
      RenderinglineLayer();
      RenderingguideLineLayer();
      updateLineAndGuideLine(takeoffPosition, airExtData)
      emit("allData", {
        type: 'drag',
        index: extData.index,
        allData: allData.value
      });
      emit("totalDistance", totalDistance.value);
    }
    // 渲染激光线图层,拖动时可见

    // 如果是2D模式，更新底部标记的样式和偏移量
    // if (previousPitch.value == 0) {
    //   const point = startdata.point;
    //   bottomMarker.setContent(`<div style="position:relative;">
    //     <div class="line-tooltip">
    //       <div>ASL: ${point[2] || 0}m</div>
    //       <div>HAE: ${point[2] || 0}m</div>
    //     </div>
    //     <div class="marker-index">T</div> </div>`);
    //   bottomMarker.setOffset(new AMap.Pixel(-15, -15));
    // }
  });
  allData.value.groundMarkers.push(marker2)
  if (previousPitch.value == 0) {
    marker2.hide()
  }
  // 只为航点添加鼠标悬浮提示框和右键菜单
  // marker.on("dragging", (e) => {
  //   const extData = marker.getExtData();
  //   const newPosition = lnglatToNumber(e.lnglat.KL, e.lnglat.kT);

  //   // 空中航点只有在按下Alt键时才允许拖动
  //   if (!isAltPressed.value) {
  //     // 如果没有按Alt键，阻止拖动，回到原位置
  //     marker.setPosition([
  //       extData.originalPosition[0],
  //       extData.originalPosition[1],
  //       extData.altitude,
  //     ]);
  //     return;
  //   }

  //   if (isAltPressed.value && isDraggingHeight.value) {
  //     // 高度调整模式 - 保持经纬度不变
  //     const pixel = map.value.lngLatToContainer([
  //       extData.originalPosition[0],
  //       extData.originalPosition[1],
  //     ]);

  //     // 计算高度变化 (每像素移动对应的高度变化量)
  //     const heightChange = (startDragY.value - e.pixel.y) * 0.5;
  //     const newHeight = Math.max(0, originalHeight.value + heightChange);

  //     // 更新高度
  //     extData.altitude = newHeight;
  //     marker.setExtData(extData);

  //     // 保持原始经纬度，只更新高度
  //     marker.setPosition([
  //       extData.originalPosition[0],
  //       extData.originalPosition[1],
  //       newHeight,
  //     ]);
  //     render_marker_height(marker);

  //     // 更新 points 数组中的坐标
  //     if (extData.index !== -1 && allData.value.points[extData.index]) {
  //       allData.value.points[extData.index] = [
  //         extData.originalPosition[0],
  //         extData.originalPosition[1],
  //         newHeight,
  //       ];
  //     }
  //     // 更新起飞点坐标（如果是起飞点）
  //     else if (extData.index === -1 && startdata.point) {
  //       startdata.point = [
  //         extData.originalPosition[0],
  //         extData.originalPosition[1],
  //         newHeight,
  //       ];
  //     }

  //     // 更新相关线段和辅助线
  //     updateLineAndGuideLine(
  //       [extData.originalPosition[0], extData.originalPosition[1], newHeight],
  //       extData
  //     );
  //   } else if (isAltPressed.value) {
  //     // 正常拖动模式 - 只有按下Alt键时才允许
  //     extData.originalPosition = [newPosition[0], newPosition[1]]; // 更新原始位置
  //     marker.setExtData({
  //       ...extData,
  //       altitude: newPosition[2] || extData.altitude,
  //     });

  //     // 更新 points 数组中的坐标（如果是航点）
  //     if (extData.index !== -1 && allData.value.points[extData.index]) {
  //       allData.value.points[extData.index] = [
  //         newPosition[0],
  //         newPosition[1],
  //         extData.altitude,
  //       ];
  //     }
  //     // 更新起飞点坐标（如果是起飞点）
  //     else if (extData.index === -1 && startdata.point) {
  //       startdata.point = [
  //         newPosition[0],
  //         newPosition[1],
  //         extData.altitude,
  //       ];
  //     }

  //     updateMarker([newPosition[0], newPosition[1], extData.altitude], extData);
  //     updateLineAndGuideLine(
  //       [newPosition[0], newPosition[1], extData.altitude],
  //       extData
  //     );
  //   }
  // });
  // 添加鼠标按下事件
  // marker.on("mousedown", (e) => {
  //   const originalEvent = e.originalEvent || e.originEvent || e;
  //   if (isAltPressed.value && originalEvent && originalEvent.button === 0) {
  //     // 左键
  //     startHeightDrag(marker, originalEvent.clientY);
  //   }
  // });

  // 添加鼠标释放事件
  // marker.on("mouseup", () => {
  //   if (isDraggingHeight.value) {
  //     endHeightDrag();
  //   }
  // });
  // if (drawing_mode.value == 1) {
  //   markers.push(marker);
  //   allData.value.markers = markers;
  //   // 添加辅助线 - 改为Point类型，从地面点创建激光线
  //   if (position && position.length >= 3) {
  //     allData.value.guideLineData.push({
  //       type: "Feature",
  //       geometry: {
  //         type: "Point",
  //         coordinates: [arithmetic.subtract(position[0], offset), position[1]], // 地面点坐标
  //       },
  //       properties: {
  //         color: "#f4ed7c",
  //         h: position[2], // 使用h属性，与mapvvvv.html保持一致
  //       },
  //     });
  //   }
  // } else if (drawing_mode.value == 2) {
  //   startdata.marker = marker;
  //   // 起飞点不需要悬浮提示功能
  //   // 添加/更新辅助线 - 改为Point类型
  //   if (position && position.length >= 3) {
  //     startdata.guideLineData = {
  //       type: "Feature",
  //       geometry: {
  //         type: "Point",
  //         coordinates: [arithmetic.subtract(position[0], offset), position[1]], // 地面点坐标
  //       },
  //       properties: {
  //         color: "#00d58f", // 改为绿色
  //         isStartGuideLine: true, // 添加标识，表示这是起始点辅助线
  //         h: position[2], // 使用h属性，与mapvvvv.html保持一致
  //       },
  //     };
  //   }
  // }

  // 更新数据源并重新渲染
  // RenderinglineLayer();
  // RenderingguideLineLayer();
  // RenderingpointLayer(); // 确保在添加航点后更新底部标记
  if (render) {
    RenderinglineLayer();
    RenderingguideLineLayer();
    // 更新渲染：距离标签
    updateLineAndGuideLine(position, {
      altitude: position[2], // 设置标识的高度
      index: index,
      originalPosition: [position[0], position[1]], // 经纬度
    })
    emit("allData", {
      type: 'add',
      index: '',
      allData: allData.value
    });
    emit("totalDistance", totalDistance.value);
    // 重新计算总距离
    calculateTotalDistance();
    set_map_for_pitch(previousPitch.value)
  }
};
// 更新航点
const updateMarker = (lnglat, extData) => {
  if (allData.value.length === 0) return;
  if (allData.value.markers[extData.index]) {
    allData.value.markers[extData.index].setExtData({
      ...allData.value.markers[extData.index].getExtData(),
      altitude: lnglat[2],
    });
    allData.value.points[extData.index] = lnglat;
    // allData.value.markers[extData.index].setPosition([
    //   lnglat[0],
    //   lnglat[1],
    // ]);
  }
  render_marker_height(allData.value.markers[extData.index]);
  RenderinglineLayer();
  RenderingguideLineLayer();
  updateDistanceLabels();
  // 重新计算总距离
  calculateTotalDistance();
  // 通知父组件数据更新
  // console.log("更新数据6", allData.value);
  // emit("allData", allData.value);
  // emit("totalDistance", totalDistance.value);
  return;
  if (extData.index != -1) {


    // 确保更新底部标记
    RenderingpointLayer();
  } else {
    if (startdata.marker) {
      startdata.point = lnglat;
      startdata.marker.setPosition([lnglat[0], lnglat[1]]);
      startdata.marker.setExtData({
        ...startdata.marker.getExtData(),
        altitude: lnglat[2],
      });
    }
    render_marker_height(startdata.marker);
    // 重新计算总距离（起飞点更新时）
    calculateTotalDistance();
    // 通知父组件数据更新
    // console.log("更新数据7", allData.value);
    emit("allData", allData.value);
    emit("totalDistance", totalDistance.value);

    // 确保更新底部标记
    // RenderingpointLayer();
  }
};
// 更新渲染距离标签
const updateLineAndGuideLine = (lnglat, extData) => {
  if (allData.value.points.length === 0) return;
  let points = allData.value.points;
  let points2 = startdata?.point || [];
  if (extData.index != -1) {
    // 检查 lineData 是否存在且有数据
    if (allData.value.lineData && allData.value.lineData.length > 0) {
      // 更新不同位置的线
      // 链接线
      if (extData.index == 0) {
        // 拖动航线首点
        if (allData.value.lineData[0]) {
          allData.value.lineData[0].geometry.coordinates[0] = lnglat;
          // 更新距离属性
          const distance = computeDis(
            lnglat,
            allData.value.lineData[0].geometry.coordinates[1]
          );
          allData.value.lineData[0].properties.distance = distance;
        }

        // 更新起飞点到航点一的连接线终点高度，确保同步
        if (points2.length > 0 && startdata.lineData.type) {
          startdata.lineData.geometry.coordinates[1] = lnglat;
          // 更新起飞点连接线距离
          const startDistance = computeDis(
            startdata.lineData.geometry.coordinates[0],
            lnglat
          );
          startdata.lineData.properties.distance = startDistance;
        }
        // 航点1拖动时，只更新连接线，不修改起飞点本身
      } else
      //  if (extData.index == allData.value.lineData.length) {
      //   // 拖动航线末点
      //   if (allData.value.lineData[extData.index - 1]) {
      //     allData.value.lineData[extData.index - 1].geometry.coordinates[1] =
      //       lnglat;
      //     // 更新距离属性
      //     const distance = calculateDistance(
      //       allData.value.lineData[extData.index - 1].geometry
      //         .coordinates[0],
      //       lnglat
      //     );
      //     allData.value.lineData[extData.index - 1].properties.distance =
      //       distance;
      //   } else {
      //     console.error(
      //       "最后一个航点对应的线段不存在，索引:",
      //       extData.index - 1
      //     );
      //   }
      // } else 
      {
        // 中间点
        if (allData.value.lineData[extData.index - 1]) {
          allData.value.lineData[extData.index - 1].geometry.coordinates[1] = lnglat;
          // 更新前一段距离
          const prevDistance = computeDis(
            allData.value.lineData[extData.index - 1].geometry
              .coordinates[0],
            lnglat
          );
          allData.value.lineData[extData.index - 1].properties.distance = prevDistance;
        }

        if (allData.value.lineData[extData.index]) {
          allData.value.lineData[extData.index].geometry.coordinates[0] =
            lnglat;
          // 更新后一段距离
          const nextDistance = computeDis(
            lnglat,
            allData.value.lineData[extData.index].geometry.coordinates[1]
          );
          allData.value.lineData[extData.index].properties.distance =
            nextDistance;
        }
      }
    }

    // 更新垂直线 - 检查 guideLineData 是否存在
    // if (
    //   allData.value.guideLineData &&
    //   allData.value.guideLineData[extData.index] &&
    //   lnglat &&
    //   lnglat.length >= 3
    // ) {
    //   // 对于Point类型，只需要更新坐标和高度属性
    //   allData.value.guideLineData[extData.index].geometry.coordinates = [
    //     arithmetic.subtract(lnglat[0], offset),
    //     lnglat[1],
    //   ];
    //   // 更新高度属性
    //   allData.value.guideLineData[extData.index].properties.h = lnglat[2];
    // }
  } else if (extData.index === -1) {
    // 起飞点拖动处理
    if (startdata.lineData) {
      if (points.length > 0) {
        // 链接线 - 使用安全起飞高度
        const takeoffHeight = startdata.value.point[2] || props.safetakeoffaltitude || 300;

        // 更新起飞点高度数据
        startdata.value.point = [lnglat[0], lnglat[1], takeoffHeight,];
        startdata.value.lineData.geometry.coordinates[0] = [lnglat[0], lnglat[1], takeoffHeight];
        startdata.value.lineData.geometry.coordinates[1] = points[0];
        // 更新起飞点连接线距离
        const startDistance = computeDis(
          startdata.value.lineData.geometry.coordinates[0],
          startdata.value.lineData.geometry.coordinates[1]
        );
        startdata.value.lineData.properties.distance = startDistance;
      }
    }
  }

  // 清除旧的距离标签并重新创建
  updateDistanceLabels();
  calculateTotalDistance(); // 在所有更新完成后重新计算距离
  // 通知父组件数据更新
  // console.log("更新数据8", allData.value);
  allData.value.type = "dragging";
  // emit("allData", allData.value);
  // emit("totalDistance", totalDistance.value);
  // RenderingpointLayer();
};
// 更新标点高度
const updateMarkerHeight = (extData, lnglat) => {
  if (allData.value.length === 0) return;

  // 更新标记点内容，包括提示框
  const content = `<div style="position:relative;">
    <div class="line-tooltip">
      <div>ASL: ${extData.altitude || 0}m</div>
      <div>HAE: ${extData.altitude || 0}m</div>
    </div>
    <div class="marker-index">${extData.index + 1}</div> </div>`;
  marker.setContent(content);
  // 更新提示框中的高度信息
  updateMarkerTooltipHeight(marker, extData.altitude || 0);

  // 确保标记点有悬浮提示功能
  if (!marker._hasTooltip) {
    addMarkerTooltip(marker, "航点");
    marker._hasTooltip = true;
  }

  // 更新 points 数组 - 这是关键修复！
  allData.value.points[extData.index] = lnglat;

  // 检查 lineData 是否存在且有数据
  if (allData.value.lineData && allData.value.lineData.length > 0) {
    // 更新不同位置的点
    if (extData.index == 0) {
      if (allData.value.lineData[0]) {
        allData.value.lineData[0].geometry.coordinates[0] = lnglat;
      }
    } else if (extData.index == allData.value.lineData.length) {
      if (allData.value.lineData[extData.index - 1]) {
        allData.value.lineData[extData.index - 1].geometry.coordinates[1] =
          lnglat;
      }
    } else {
      if (allData.value.lineData[extData.index - 1]) {
        allData.value.lineData[extData.index - 1].geometry.coordinates[1] =
          lnglat;
      }
      if (allData.value.lineData[extData.index]) {
        allData.value.lineData[extData.index].geometry.coordinates[0] =
          lnglat;
      }
    }
  } else {
    // 当只有一个航点时，lineData 为空，但需要更新起飞点连接线
    if (
      startdata.value.point &&
      startdata.value.point.length > 0 &&
      startdata.value.lineData
    ) {
      startdata.value.lineData.geometry.coordinates[1] = lnglat;
      // 更新起飞点连接线距离
      const startDistance = computeDis(
        startdata.value.lineData.geometry.coordinates[0],
        lnglat
      );
      startdata.value.lineData.properties.distance = startDistance;
    }
  }

  // 更新垂直线 - 检查 guideLineData 是否存在
  if (
    allData.value.guideLineData &&
    allData.value.guideLineData[extData.index] &&
    lnglat &&
    lnglat.length >= 3
  ) {
    // 对于Point类型，只需要更新坐标和高度属性
    allData.value.guideLineData[extData.index].geometry.coordinates = [
      arithmetic.subtract(lnglat[0], offset),
      lnglat[1],
    ];
    // 更新高度属性
    allData.value.guideLineData[extData.index].properties.h = lnglat[2];
  }

  // 清除旧的距离标签并重新创建
  updateDistanceLabels();
  // 重新计算总距离
  calculateTotalDistance();
  // 通知父组件数据更新
  // console.log("更新数据9", allData.value);
  // emit("allData", allData.value);
  emit("totalDistance", totalDistance.value);

  RenderinglineLayer();
  RenderingguideLineLayer();
};
// 更新距离标签
const updateDistanceLabels = () => {
  // 清除现有距离标签
  clearDistanceMarkers();

  // 检查数据结构是否存在
  if (!allData.value || allData.value.points.length === 0) {
    console.warn("updateDistanceLabels: allData 为空");
    return;
  }
  // 临时数组存储所有距离
  const tempDistanceArray = [];
  // 更新起飞点连接线距离标签
  if (startdata.value?.lineData?.geometry?.coordinates) {
    const coordinates = startdata.value.lineData.geometry.coordinates;
    if (coordinates && coordinates.length >= 2) {
      const [start, end] = coordinates;
      const distance = computeDis(start, end);
      addDistanceLabel(start, end, distance, true);
      tempDistanceArray.push(distance); // 添加到临时距离数组
    }
  }

  // 更新起始点辅助线距离标签
  if (startdata.value?.guideLineData?.geometry?.coordinates) {
    const coordinates =
      startdata.value.guideLineData.geometry.coordinates;
    if (coordinates && coordinates.length >= 2) {
      // 对于Point类型的辅助线，需要构造两个点来计算距离
      const groundPoint = [coordinates[0], coordinates[1], 0]; // 地面点，高度为0
      const airPoint = [
        coordinates[0] + offset, // 空中点的经度（地面点经度 + offset）
        coordinates[1], // 空中点的纬度
        startdata.value.guideLineData.properties.h || 0, // 空中点的高度
      ];
      const distance = computeDis(groundPoint, airPoint);
      addDistanceLabel(groundPoint, airPoint, distance, false, true); // 添加参数表示是起始点辅助线
      tempDistanceArray.push(distance); // 添加到临时距离数组
    }
  }

  // 更新航点间线段距离标签
  if (allData.value.lineData && Array.isArray(allData.value.lineData)) {
    allData.value.lineData.forEach((line) => {
      if (
        line?.geometry?.coordinates &&
        line.geometry.coordinates.length >= 2
      ) {
        const [start, end] = line.geometry.coordinates;
        const distance = computeDis(start, end);
        addDistanceLabel(start, end, distance);
        tempDistanceArray.push(distance); // 添加到临时距离数组
      }
    });
  }

  // 更新距离数组
  distanceArray.value = tempDistanceArray;
  emit("distanceArray", distanceArray.value);
};
// 添加距离标签
const addDistanceLabel = (
  start,
  end,
  distance,
  isStartLine = false,
  isStartGuideLine = false
) => {
  // 参数验证
  if (!start || !end) {
    console.warn("addDistanceLabel: 无效的参数", { start, end, distance });
    return;
  }

  // 确保坐标点是数组格式
  if (!Array.isArray(start) || !Array.isArray(end)) {
    console.warn("addDistanceLabel: 坐标点必须是数组格式", {
      start,
      end,
      distance,
    });
    return;
  }

  // 确保有经纬度信息
  if (
    typeof start[0] !== "number" ||
    typeof start[1] !== "number" ||
    typeof end[0] !== "number" ||
    typeof end[1] !== "number"
  ) {
    console.warn("addDistanceLabel: 坐标点缺少必要的经纬度信息", {
      start: start,
      end: end,
      distance: distance,
    });
    return;
  }

  const midLng = (start[0] + end[0]) / 2;
  const midLat = (start[1] + end[1]) / 2;
  // 2D模式下距离标签高度为0，3D模式下使用真实高度
  const midHeight = previousPitch.value != 0 ? (start[2] + end[2]) / 2 : 0;

  // 如果是起飞点辅助线，显示高度值而不是距离值
  let displayText;
  if (isStartGuideLine && startdata.value?.point?.[2] !== undefined) {
    // 使用起飞点的实际高度值
    displayText = `${startdata.value.point[2]}m`;
  } else {
    // 其他情况显示四舍五入的距离值
    displayText = `${Math.round(distance)}m`;
  }

  const textMarker = new AMap.Text({
    text: displayText,
    position: [midLng, midLat, midHeight],
    style: {
      "background-color": isStartGuideLine
        ? "rgba(0,213,143,0.8)"
        : "rgba(0,0,0,0.8)", // 起始点辅助线用绿色背景
      "border-radius": "4px",
      padding: "2px 6px",
      color: "#ffffff",
      "font-size": "12px",
      "font-weight": "bold",
    },
    offset: new AMap.Pixel(0, -10),
  });

  map.value.add(textMarker);

  // 存储标记以便后续清除
  if (!allData.value.distanceMarkers) {
    allData.value.distanceMarkers = [];
  }
  allData.value.distanceMarkers.push(textMarker);
};
// 开始高度拖动
const startHeightDrag = (marker, startY) => {
  isDraggingHeight.value = true;
  currentDraggingMarker.value = marker;
  startDragY.value = startY;
  originalHeight.value = marker.getExtData().altitude;
};

// 结束高度拖动
const endHeightDrag = () => {
  isDraggingHeight.value = false;
  currentDraggingMarker.value = null;
  // 重新计算总距离
  calculateTotalDistance();
  // 通知父组件数据更新
  // console.log("更新数据10", allData.value);
  emit("allData", allData.value);
  emit("totalDistance", totalDistance.value);
};
// 清除距离标签
const clearDistanceMarkers = () => {
  if (allData.value.distanceMarkers) {
    allData.value.distanceMarkers.forEach((marker) => {
      map.value.remove(marker);
    });
    allData.value.distanceMarkers = [];
  }
};
// 更新渲染点高度
const render_marker_height = (marker) => {
  // 移除之前的事件监听器，避免重复绑定
  marker.off("positionUpdate");
  marker.on("positionUpdate", function () {
    let altitude = this.getExtData().altitude || 0;
    if (previousPitch.value == 0) altitude = 0;//2d模式判断
    const newPosition = [
      this.getPosition().lng,
      this.getPosition().lat,
      altitude,
    ];
    this.setPosition(newPosition);
  });
  marker.emit("positionUpdate");
};
// 更新点指定高度
const updata_marker_height = (marker, height) => {
  // 移除之前的事件监听器，避免重复绑定
  marker.off("positionUpdate");

  marker.on("positionUpdate", function () {
    // console.log(height)
    const extData = this.getExtData();
    var altitude = ((height || height == 0) ? height : extData.altitude);
    extData.altitude = altitude
    if (previousPitch.value == 0) altitude = 0;//2d模式判断
    const newPosition = [
      this.getPosition().lng,
      this.getPosition().lat,
      altitude,
    ];
    this.setExtData(extData)
    // 如果是起飞点标记，使用保存的原始位置进行检查
    // if (extData.index === -1 && window.originalTakeoffPosition) {
    //   const savedOriginalPosition = window.originalTakeoffPosition;
    //   const distanceFromSaved = Math.sqrt(
    //     Math.pow(newPosition[0] - savedOriginalPosition[0], 2) +
    //     Math.pow(newPosition[1] - savedOriginalPosition[1], 2)
    //   );
    // }
    this.setPosition(newPosition);
  });
  marker.emit("positionUpdate");
};
// 为标记点添加悬浮提示功能
const addMarkerTooltip = (marker, markerType = "航点") => {
  // 鼠标悬浮显示高度
  marker.on("mouseover", (e) => {
    // 获取当前标记点的DOM元素
    if (isAltPressed.value) return;
    const markerElement = marker.getContent();
    // 获取当前标记点的高度信息
    const extData = marker.getExtData();
    // 使用真实高度显示ASL/HAE，确保始终显示真实高度
    const currentAltitude =
      extData.index !== -1 && allData.value.points[extData.index]
        ? allData.value.points[extData.index][2]
        : extData.altitude || 0;
    // 如果返回的是字符串，需要先转换为DOM元素
    let domElement = null;
    if (typeof markerElement === "string") {
      // 创建临时容器来解析HTML字符串
      const tempDiv = document.createElement("div");
      tempDiv.innerHTML = markerElement;
      domElement = tempDiv.firstElementChild;
    } else if (
      markerElement &&
      typeof markerElement.querySelector === "function"
    ) {
      domElement = markerElement;
    }

    if (domElement) {
      // 在当前标记点内查找对应的提示框
      const tooltipElement = domElement.querySelector(".line-tooltip");
      if (tooltipElement) {
        // 更新提示框中的高度信息
        const aslElement = tooltipElement.querySelector("div:first-child");
        const haeElement = tooltipElement.querySelector("div:last-child");

        if (aslElement) {
          aslElement.textContent = `ASL: ${currentAltitude}m`;
        }
        if (haeElement) {
          haeElement.textContent = `HAE: ${currentAltitude}m`;
        }

        tooltipElement.style.display = "block";
        // 更新标记点内容以显示提示框
        marker.setContent(domElement.outerHTML);
      }
    }
  });

  // 鼠标离开隐藏提示框
  marker.on("mouseout", (e) => {
    // 获取当前标记点的DOM元素
    const markerElement = marker.getContent();

    // 如果返回的是字符串，需要先转换为DOM元素
    let domElement = null;
    if (typeof markerElement === "string") {
      // 创建临时容器来解析HTML字符串
      const tempDiv = document.createElement("div");
      tempDiv.innerHTML = markerElement;
      domElement = tempDiv.firstElementChild;
    } else if (
      markerElement &&
      typeof markerElement.querySelector === "function"
    ) {
      domElement = markerElement;
    }

    if (domElement) {
      // 在当前标记点内查找对应的提示框
      const tooltipElement = domElement.querySelector(".line-tooltip");
      if (tooltipElement) {
        tooltipElement.style.display = "none";
        // 更新标记点内容以隐藏提示框
        marker.setContent(domElement.outerHTML);
      }
    }
  });
};
// 渲染线段
const RenderinglineLayer = () => {
  // 更新渲染线段
  let arr = [];
  let is_h0 = previousPitch.value == 0;
  let linelist = []
  if (allData.value.points && allData.value.points.length > 1) {
    for (let i = 0; i < allData.value.points.length - 1; i++) {
      const startPoint = allData.value.points[i];
      const endPoint = allData.value.points[i + 1];
      linelist.push({
        type: "Feature",
        geometry: {
          type: "LineString",
          coordinates: [
            [startPoint[0], startPoint[1], is_h0 ? 0 : startPoint[2]],
            [endPoint[0], endPoint[1], is_h0 ? 0 : endPoint[2]],
          ],
        },
        properties: {
          color: "#ff0000",
          weight: 3,
          distance: ''
        },
      });
    }
  }
  allData.value.lineData = linelist;
  arr = [...linelist]
  // 处理起飞点到第一个航点的连接线
  if (startdata.value.point.length > 0 && allData.value.points.length > 0) {
    const startPoint = startdata.value.point;
    const firstWaypoint = allData.value.points[0];
    startdata.value.lineData = {
      type: "Feature",
      geometry: {
        type: "LineString",
        coordinates: [
          [startPoint[0], startPoint[1], is_h0 ? 0 : startPoint[2]], // 地上坐标
          [firstWaypoint[0], firstWaypoint[1], is_h0 ? 0 : firstWaypoint[2]], // 地上坐标
        ],
      },
      properties: {
        color: "#00ff00",
        weight: 3,
        distance: ''
      },
    };
    arr.push(startdata.value.lineData)
  }
  // 根据当前视图模式决定使用哪种连接线数据
  // if (previousPitch.value != 0) {
  //   // 3D模式：使用真实高度的连接线
  //   if (allData.value.lineData.length > 0) {
  //     const data = allData.value;
  //     if (Array.isArray(data.lineData)) {
  //       arr = arr.concat(...data.lineData);
  //     }
  //     if (startdata?.lineData?.type) {
  //       arr.push(startdata.lineData);
  //     }
  //   }
  // } else {
  //   // 2D模式：使用地上坐标的连接线
  //   if (allData.value.length > 0) {
  //     // 创建地上坐标的线段数据
  //     const groundLineData = [];
  //     // 处理航点之间的连接线
  //     arr = groundLineData;
  //   }
  // }
  // 检查 lineLayer 是否存在
  if (window.lineLayer) {
    window.lineLayer.setSource(
      new window.Loca.GeoJSONSource({
        data: {
          type: "FeatureCollection",
          features: arr,
        },
      })
    );
    window.lineLayer.render();
  } else {
    // console.error("window.lineLayer 不存在");
  }
};
// 更新渲染辅助线(垂直线)
const RenderingguideLineLayer = () => {
  let arr = [];
  let is_h0 = previousPitch.value == 0; // 判断视图模式
  let guideLineData = [];
  if (allData.value.points && allData.value.points.length > 0) {
    for (let i in allData.value.points) {
      const Point = allData.value.points[i];
      guideLineData.push({
        type: "Feature",
        geometry: {
          type: "Point",
          coordinates: [arithmetic.subtract(Point[0], offset), Point[1]]
        },
        properties: {
          color: "#f4ed7c",
          h: is_h0 ? 0 : Point[2],
        },
      });
    }
  }
  allData.value.guideLineData = guideLineData;
  arr = [...guideLineData]
  if (startdata.value.point.length > 0) {
    const Point = startdata.value.point;
    startdata.value.guideLineData = {
      type: "Feature",
      geometry: {
        type: "Point",
        coordinates: [Point[0], Point[1]], // 地上坐标
      },
      properties: {
        color: "#00ff00",
        h: is_h0 ? 0 : Point[2],
      },
    };
    arr.push(startdata.value.guideLineData)
  }
  // 检查 guideLineLayer 是否存在
  if (window.guideLineLayer) {
    const currentZoom = map.value.getZoom();
    let newLineWidth;
    // 根据zoom级别设置线条粗细，zoom越大线条越细
    if (currentZoom >= 19.5) {
      newLineWidth = 0.7; // 最高级别，最细线条
    } else if (currentZoom >= 19) {
      newLineWidth = 1.0;
    } else if (currentZoom >= 18.5) {
      newLineWidth = 1.2;
    } else if (currentZoom >= 18) {
      newLineWidth = 1.6;
    } else if (currentZoom >= 17.5) {
      newLineWidth = 2.0;
    } else if (currentZoom >= 17) {
      newLineWidth = 3.0;
    } else if (currentZoom >= 16.5) {
      newLineWidth = 4.0;
    } else if (currentZoom >= 16) {
      newLineWidth = 6.0;
    } else {
      newLineWidth = 7.0; // 最低级别，最粗线条
    }
    if (previousPitch.value === 0) {
      arr = []
    }
    // 保持静态辅助线效果并更新线条宽度
    window.guideLineLayer.setSource(
      new window.Loca.GeoJSONSource({
        data: {
          type: "FeatureCollection",
          features: arr,
        },
      }),
      {
        unit: "meter",
        height: (index, feature) => {
          return feature.properties.h || 0;
        },
        color: "#f0ed7a", // 黄色辅助线
        lineWidth: newLineWidth, // 使用新的线条宽度
        trailLength: 50000, // 设置为0，禁用流动效果
        repeat: 0, // 不重复
      }
    );
    window.guideLineLayer.render();
  } else {
    // console.error("window.guideLineLayer 不存在");
  }
};

// 底部圆点marker数组
const bottomMarkers = ref([]);

// 更新渲染圆点图层
// const RenderingpointLayer = () => {
//   // 清除现有的底部marker
//   allData.value.groundMarkers.forEach((marker) => {
//     map.value.remove(marker);
//   });
//   allData.value.groundMarkers = [];

//   // 单航线模式：直接处理第一个航线
//   if (allData.value.length > 0) {
//     const route = allData.value;

//     // 处理起飞点底部标记
//     if (route.startdata && route.startdata.point && route.startdata.point.length > 0) {
//       const takeoffPoint = route.startdata.point;
//       const bottomMarker = new AMap.Marker({
//         position: [takeoffPoint[0], takeoffPoint[1], 0], // 地面位置
//         content: previousPitch.value != 0
//           ? `<div style="width:8px;height:8px;background:#f0ed7a;border-radius:50%;border:1px solid #fff;"></div>`
//           : `<div style="position:relative;">
//     <div class="line-tooltip">
//       <div>ASL: ${takeoffPoint[2] || 0}m</div> 
//       <div>HAE: ${takeoffPoint[2] || 0}m</div>
//     </div>
//     <div class="marker-index">T</div> </div>`,
//         offset: previousPitch.value != 0
//           ? new AMap.Pixel(-4, -8) // 3D模式偏移量
//           : new AMap.Pixel(-15, -15), // 2D模式偏移量
//         extData: {
//           index: -1, // 起飞点索引为-1
//           isBottomMarker: true, // 标识这是底部marker
//           originalPosition: [takeoffPoint[0], takeoffPoint[1]],
//           altitude: takeoffPoint[2] || 0, // 保存高度信息
//         },
//         draggable: true,
//         zIndex: 100, // 确保在辅助线上方
//       });

//       // 添加起飞点底部标记的事件处理
//       bottomMarker.on("dragging", (e) => {
//         const extData = bottomMarker.getExtData();
//         const newPosition = lnglatToNumber(e.lnglat.KL, e.lnglat.kT);

//         // 更新起飞点底部标记位置
//         bottomMarker.setExtData(extData);

//         // 更新起飞点空中坐标的经纬度，保持高度不变
//         if (startdata.point) {
//           const currentAltitude = startdata.point[2];
//           startdata.point = [
//             newPosition[0],
//             newPosition[1],
//             currentAltitude,
//           ];
//         }

//         // 更新起飞点空中marker位置和originalPosition
//         if (startdata.marker) {
//           const airMarker = startdata.marker;
//           const airExtData = airMarker.getExtData();
//           airExtData.originalPosition = [newPosition[0], newPosition[1]];
//           airMarker.setExtData(airExtData);
//           airMarker.setPosition([
//             newPosition[0],
//             newPosition[1],
//             startdata.point[2],
//           ]);
//         }

//         // 更新辅助线
//         updateLineAndGuideLine(
//           [
//             newPosition[0],
//             newPosition[1],
//             startdata.point?.[2] || 0,
//           ],
//           extData
//         );

//         // 立即重新渲染激光线图层，确保拖动时可见
//         if (window.guideLineLayer) {
//           RenderingguideLineLayer();
//         }

//         // 如果是2D模式，更新底部标记的样式和偏移量
//         if (previousPitch.value == 0) {
//           const point = startdata.point;
//           bottomMarker.setContent(`<div style="position:relative;">
//     <div class="line-tooltip">
//       <div>ASL: ${point[2] || 0}m</div>
//       <div>HAE: ${point[2] || 0}m</div>
//     </div>
//     <div class="marker-index">T</div> </div>`);
//           bottomMarker.setOffset(new AMap.Pixel(-15, -15));
//         }
//       });

//       map.value.add(bottomMarker);
//       allData.value.groundMarkers.push(bottomMarker);
//     }

//     if (Array.isArray(route.points)) {
//       // 为每个航点创建地面圆点marker
//       route.points.forEach((point, index) => {
//         const bottomMarker = new AMap.Marker({
//           position: [point[0], point[1], 0], // 地面位置
//           content: previousPitch.value != 0
//             ? `<div style="width:8px;height:8px;background:#f0ed7a;border-radius:50%;border:1px solid #fff;"></div>`
//             : `<div style="position:relative;">
//     <div class="line-tooltip">
//       <div>ASL: ${point[2] || 0}m</div> 
//       <div>HAE: ${point[2] || 0}m</div>
//     </div>
//     <div class="marker-index">${index + 1}</div> </div>`,
//           offset: previousPitch.value != 0
//             ? new AMap.Pixel(-4, -8) // 3D模式偏移量
//             : new AMap.Pixel(-15, -15), // 2D模式偏移量
//           extData: {
//             index: index,
//             isBottomMarker: true, // 标识这是底部marker
//             originalPosition: [point[0], point[1]],
//             altitude: point[2] || 0, // 保存高度信息
//           },
//           draggable: true,
//           zIndex: 100, // 确保在辅助线上方
//         });

//         // 添加鼠标悬停事件 - 显示拖动光标
//         bottomMarker.on("mouseover", (e) => {
//           if (map.value) {
//             map.value.getContainer().style.cursor = "move";
//           }
//         });

//         bottomMarker.on("mouseout", (e) => {
//           if (map.value) {
//             // 恢复默认光标样式
//             if (drawing_mode.value == 2) {
//               map.value.getContainer().style.cursor = "crosshair";
//             } else {
//               map.value.getContainer().style.cursor = drawing_mode.value != 3
//                 ? "crosshair"
//                 : "default";
//             }
//           }
//         });

//         // 添加拖动事件
//         bottomMarker.on("dragging", (e) => {
//           const extData = bottomMarker.getExtData();
//           const newPosition = lnglatToNumber(e.lnglat.KL, e.lnglat.kT);

//           // 更新底部坐标 - 不更新originalPosition，避免影响高度调整
//           bottomMarker.setExtData(extData);

//           // 更新空中坐标的经纬度，保持高度不变
//           if (extData.index !== -1 && allData.value.points[extData.index]) {
//             const currentAltitude = allData.value.points[extData.index][2];
//             allData.value.points[extData.index] = [
//               newPosition[0],
//               newPosition[1],
//               currentAltitude,
//             ];
//           } else if (extData.index === -1 && startdata.point) {
//             const currentAltitude = startdata.point[2];
//             startdata.point = [
//               newPosition[0],
//               newPosition[1],
//               currentAltitude,
//             ];
//           }

//           // 更新空中marker位置和originalPosition
//           if (extData.index !== -1 && allData.value.markers[extData.index]) {
//             const airMarker = allData.value.markers[extData.index];
//             const airExtData = airMarker.getExtData();
//             airExtData.originalPosition = [newPosition[0], newPosition[1]];
//             airMarker.setExtData(airExtData);
//             airMarker.setPosition([
//               newPosition[0],
//               newPosition[1],
//               allData.value.points[extData.index][2],
//             ]);
//           } else if (
//             extData.index === -1 &&
//             startdata.marker
//           ) {
//             const airMarker = startdata.marker;
//             const airExtData = airMarker.getExtData();
//             airExtData.originalPosition = [newPosition[0], newPosition[1]];
//             airMarker.setExtData(airExtData);
//             airMarker.setPosition([
//               newPosition[0],
//               newPosition[1],
//               startdata.point[2],
//             ]);
//           }

//           // 更新辅助线
//           updateLineAndGuideLine(
//             [
//               newPosition[0],
//               newPosition[1],
//               allData.value.points[extData.index]?.[2] ||
//               startdata.point[2],
//             ],
//             extData
//           );

//           // 立即重新渲染激光线图层，确保拖动时可见
//           if (window.guideLineLayer) {
//             RenderingguideLineLayer();
//           }

//           // 如果是2D模式，更新底部标记的样式和偏移量
//           if (previousPitch.value == 0) {
//             const point =
//               extData.index !== -1
//                 ? allData.value.points[extData.index]
//                 : startdata.point;
//             bottomMarker.setContent(`<div style="position:relative;">
//     <div class="line-tooltip">
//       <div>ASL: ${point[2] || 0}m</div>
//       <div>HAE: ${point[2] || 0}m</div>
//     </div>
//     <div class="marker-index">${extData.index === -1 ? "T" : extData.index + 1
//               }</div> </div>`);
//             bottomMarker.setOffset(new AMap.Pixel(-15, -15));

//             // 重新添加tooltip功能
//             addMarkerTooltip(bottomMarker, "航点");

//             // 重新添加右键删除事件
//             bottomMarker.on("rightclick", (e) => {
//               showDeleteButtonHandler(e, extData.index);
//             });
//           }
//         });

//         // 添加拖动结束事件，确保2D模式下保持正确的偏移量
//         bottomMarker.on("dragend", (e) => {
//           if (previousPitch.value != 0) {
//             // 2D模式下确保偏移量正确
//             bottomMarker.setOffset(new AMap.Pixel(-15, -15));
//           }
//         });

//         // 为底部标记添加tooltip功能
//         addMarkerTooltip(bottomMarker, "航点");

//         // 为底部标记添加双击事件 - 只在2D模式下添加
//         if (previousPitch.value != 0) {
//           bottomMarker.on("dblclick", (e) => {
//             // 双击事件 - 将航点数据传给父元素
//             const position = bottomMarker.getPosition();
//             const extData = bottomMarker.getExtData();
//             const waypointData = {
//               lng: position.lng,
//               lat: position.lat,
//               altitude: allData.value.points[extData.index]
//                 ? allData.value.points[extData.index][2]
//                 : 0,
//               index: extData.index,
//             };

//             // 发送给父组件
//             emit("waypointDoubleClick", waypointData);
//           });
//         }

//         // 为底部标记添加右键删除事件
//         bottomMarker.on("rightclick", (e) => {
//           showDeleteButtonHandler(e, index);
//         });
//         map.value.add(bottomMarker);
//         allData.value.groundMarkers.push(bottomMarker);
//       });
//     }
//   }
// };

// 2D模式：重新绘制连接线，使用地上坐标（高度为0）
// const updateLineHeightFor2D = () => {
//   if (allData.value.length > 0) {
//     // 创建地上坐标的线段数据
//     const groundLineData = [];

//     // 处理航点之间的连接线
//     if (allData.value.points && allData.value.points.length > 1) {
//       for (let i = 0; i < allData.value.points.length - 1; i++) {
//         const startPoint = allData.value.points[i];
//         const endPoint = allData.value.points[i + 1];

//         groundLineData.push({
//           type: "Feature",
//           geometry: {
//             type: "LineString",
//             coordinates: [
//               [startPoint[0], startPoint[1], 0], // 地上坐标
//               [endPoint[0], endPoint[1], 0], // 地上坐标
//             ],
//           },
//           properties: {
//             color: "#ff0000",
//             weight: 3,
//           },
//         });
//       }
//     }

//     // 处理起飞点到第一个航点的连接线
//     if (
//       startdata &&
//       startdata.point &&
//       allData.value.points.length > 0
//     ) {
//       const startPoint = startdata.point;
//       const firstWaypoint = allData.value.points[0];

//       groundLineData.push({
//         type: "Feature",
//         geometry: {
//           type: "LineString",
//           coordinates: [
//             [startPoint[0], startPoint[1], 0], // 地上坐标
//             [firstWaypoint[0], firstWaypoint[1], 0], // 地上坐标
//           ],
//         },
//         properties: {
//           color: "#00ff00",
//           weight: 3,
//         },
//       });
//     }

//     // 更新线段图层
//     if (window.lineLayer) {
//       window.lineLayer.setSource(
//         new window.Loca.GeoJSONSource({
//           data: {
//             type: "FeatureCollection",
//             features: groundLineData,
//           },
//         })
//       );
//       window.lineLayer.render();
//     }
//   }

//   // 确保更新底部标记
//   RenderingpointLayer();
// };

// 3D模式：重新绘制连接线，使用真实高度
// const updateLineHeightFor3D = () => {
//   if (allData.value.length > 0) {
//     // 重新构建线段数据以恢复真实高度
//     // rebuildLineData();
//     RenderinglineLayer();
//   }
// };

// 显示删除按钮
const showDeleteButtonHandler = (event, waypointIndex) => {
  // 通过标记点的位置找到对应的航点索引
  let actualIndex = waypointIndex;
  const waypoint = allData.value.points[actualIndex];
  if (!waypoint) {
    console.error(
      "未找到航点数据，索引:",
      actualIndex,
      "总航点数:",
      allData.value.points.length
    );
    return;
  }
  selectedWaypointIndex.value = actualIndex;
  // 用鼠标事件的位置来定位删除按钮
  if (event && event.pixel) {
    // 直接使用鼠标点击的像素位置
    deleteButtonPosition.value = {
      x: event.pixel.x + 10, // 向右偏移10像素
      y: event.pixel.y - 10, // 使用鼠标点击的Y坐标
    };
  }
  showDeleteButton.value = true;
};

// 隐藏删除按钮
const hideDeleteButton = () => {
  showDeleteButton.value = false;
};

// 删除航点
const deleteWaypoint = () => {
  // hasUserInteracted.value = true; // 标记用户已进行交互
  if (selectedWaypointIndex.value >= 0) {
    const index = selectedWaypointIndex.value;
    // console.log(index)
    // 移除航点
    allData.value.points.splice(index, 1);
    // 移除标记点
    if (allData.value.markers[index]) {
      map.value.remove(allData.value.markers[index]);
      allData.value.markers.splice(index, 1);
    }
    // 移除对应的底部marker
    if (allData.value.groundMarkers[index]) {
      // allData.value.groundMarkers.forEach((marker) => {
      //   map.value.remove(marker);
      // });
      map.value.remove(allData.value.groundMarkers[index]);
      allData.value.groundMarkers.splice(index, 1);
    }
    // 移除辅助线
    // if (allData.value.guideLineData[index]) {
    //   allData.value.guideLineData.splice(index, 1);
    // }
    // rebuildLineData();
    // 更新所有标记点的索引
    updateMarkerIndexes(index);
    // 重新构建线段数据
    RenderinglineLayer();
    RenderingguideLineLayer();
    // 清除距离标签并重新创建
    updateDistanceLabels();
    // 重新计算总距离
    calculateTotalDistance();
    // 通知父组件数据更新
    // console.log("更新数据11", allData.value);
    emit("allData", {
      type: 'del',
      index,
      allData: allData.value
    });
    emit("totalDistance", totalDistance.value);
    // 重新渲染
    // RenderinglineLayer();
    // RenderingpointLayer();
    ElMessage.success("航点删除成功");
  }

  hideDeleteButton();
  selectedWaypointIndex.value = -1;
};

// 防抖版本的数据更新函数
// const debouncedEmitAllData = () => {
//   // 清除之前的定时器
//   if (dataUpdateDebounceTimer) {
//     clearTimeout(dataUpdateDebounceTimer);
//   }

//   // 设置新的防抖定时器
//   dataUpdateDebounceTimer = setTimeout(() => {
//     emit("allData", allData.value);
//     emit("totalDistance", totalDistance.value);
//   }, DATA_UPDATE_DEBOUNCE_DELAY);
// };

// 更新防抖版本的总距离更新函数
// const debouncedEmitTotalDistance = (distance) => {
//   // 清除之前的定时器
//   if (dataUpdateDebounceTimer) {
//     clearTimeout(dataUpdateDebounceTimer);
//   }

//   // 设置新的防抖定时器
//   dataUpdateDebounceTimer = setTimeout(() => {
//     emit("totalDistance", distance);
//   }, DATA_UPDATE_DEBOUNCE_DELAY);
// };

// 批量构建线段数据
// const rebuildLineData = () => {
//   if (allData.value.points.length === 0) return;
//   const points = allData.value.points;
//   const newLineData = [];
//   // 重新构建航点间的线段
//   // for (let i in points) {
//   //   updateLineAndGuideLine(position, {
//   //     altitude: position[2], // 设置标识的高度
//   //     index: index,
//   //     originalPosition: [position[0], position[1]], // 经纬度
//   //   })
//   // }
//   return;
//   allData.value.lineData = newLineData;
//   // 重新构建航点辅助线 - 改为Point类型
//   const newGuideLineData = [];
//   for (let i = 0; i < points.length; i++) {
//     // 检查points[i]是否存在且包含必要的坐标
//     if (points[i] && points[i].length >= 3) {
//       newGuideLineData.push({
//         type: "Feature",
//         geometry: {
//           type: "Point",
//           coordinates: [
//             arithmetic.subtract(points[i][0], offset),
//             points[i][1],
//           ], // 地面点坐标
//         },
//         properties: {
//           color: "#f4ed7c",
//           h: points[i][2], // 使用h属性，与mapvvvv.html保持一致
//         },
//       });
//     }
//   }
//   allData.value.guideLineData = newGuideLineData;

//   // 重新构建起始点连接线和辅助线
//   if (
//     startdata.point &&
//     startdata.point.length > 0
//   ) {
//     if (points.length > 0) {
//       // 保持起飞点的经纬度不变，高度使用安全起飞高度
//       const originalLng = startdata.point[0];
//       const originalLat = startdata.point[1];
//       const takeoffHeight =
//         props.safetakeoffaltitude || startdata.point[2] || 300;
//       startdata.point = [
//         originalLng,
//         originalLat,
//         takeoffHeight,
//       ];

//       // 如果有航点，连接到第一个航点
//       startdata.lineData = {
//         type: "Feature",
//         geometry: {
//           type: "LineString",
//           coordinates: [startdata.point, points[0]],
//         },
//         properties: {
//           color: "#3366ff",
//           distance: calculateDistance(
//             startdata.point,
//             points[0]
//           ),
//         },
//       };

//       // 重新构建起始点辅助线 - 改为Point类型
//       if (
//         startdata.point &&
//         startdata.point.length >= 3
//       ) {
//         startdata.guideLineData = {
//           type: "Feature",
//           geometry: {
//             type: "Point",
//             coordinates: [
//               arithmetic.subtract(startdata.point[0], offset),
//               startdata.point[1],
//             ], // 地面点坐标
//           },
//           properties: {
//             isStartGuideLine: true, // 添加标识，表示这是起始点辅助线
//             h: startdata.point[2], // 使用h属性，与mapvvvv.html保持一致
//           },
//         };
//       }
//     } else {
//       // 如果没有航点，清除起始点连接线，但保留辅助线
//       startdata.lineData = null;

//       // 重新构建起始点辅助线 - 即使没有航点也要保留
//       if (
//         startdata.point &&
//         startdata.point.length >= 3
//       ) {
//         startdata.guideLineData = {
//           type: "Feature",
//           geometry: {
//             type: "Point",
//             coordinates: [
//               arithmetic.subtract(startdata.point[0], offset),
//               startdata.point[1],
//             ], // 地面点坐标
//           },
//           properties: {
//             isStartGuideLine: true, // 添加标识，表示这是起始点辅助线
//             h: startdata.point[2], // 使用h属性，与mapvvvv.html保持一致
//           },
//         };
//       }
//     }
//   }

//   // 更新圆点图层
//   RenderingpointLayer();
// };

// 更新标记点索引
const updateMarkerIndexes = (i) => {
  if (allData.value.points.length === 0) return;
  allData.value.markers.forEach((marker, index) => {
    const extData = marker.getExtData();
    extData.index = index;
    marker.setExtData(extData);
    // 更新标记点内容（编号），保持提示框结构
    let content = `<div style="position:relative;">
    <div class="line-tooltip">
      <div>ASL: ${extData.altitude || 0}m</div>
      <div>HAE: ${extData.altitude || 0}m</div>
    </div>
    <div class="marker-index">${index + 1}</div> </div>`;
    // console.log(index, props.selectedWayPoint.index, i)
    if (props.selectedWayPoint && ((props.selectedWayPoint.index > i && props.selectedWayPoint.index - 1 == index) || (props.selectedWayPoint.index < i && props.selectedWayPoint.index == index))) {
      content = `
            <div style="position:relative;">
              <div class="line-tooltip">
                <div>ASL: ${props.selectedWayPoint.altitude || 0}m</div>
                <div>HAE: ${props.selectedWayPoint.altitude || 0}m</div>
              </div>
              <div class="marker-index" style="background-color: #2f69eb; color: #ffffff; border: 2px solid #ffffff;">${index + 1
        }</div>
            </div>
          `
    }
    marker.setContent(content);
    // 更新提示框中的高度信息
    updateMarkerTooltipHeight(marker, extData.altitude || 0);
  });
  allData.value.groundMarkers.forEach((marker, index) => {
    const extData = marker.getExtData();
    extData.index = index;
    marker.setExtData(extData);
  });
  // 确保更新底部标记
  // RenderingpointLayer();
};

// 更新特定航点的坐标
const updateWaypointCoordinate = (waypointIndex, longitude, latitude) => {
  try {
    // 验证参数
    if (
      waypointIndex === undefined ||
      waypointIndex === null ||
      waypointIndex < 0 ||
      waypointIndex >= allData.value.points.length
    ) {
      console.error("无效的航点索引:", waypointIndex);
      return;
    }

    if (isNaN(longitude) || isNaN(latitude)) {
      console.error("经纬度格式无效");
      return;
    }

    // 验证经纬度范围
    if (longitude < -180 || longitude > 180) {
      console.error("经度范围应在-180~180之间");
      return;
    }

    if (latitude < -90 || latitude > 90) {
      console.error("纬度范围应在-90~90之间");
      return;
    }

    // 更新航点坐标
    const currentPoint = allData.value.points[waypointIndex];
    const originalHeight = currentPoint[2] || 300; // 保持原有高度
    allData.value.points[waypointIndex] = [
      longitude,
      latitude,
      originalHeight,
    ];

    // 更新对应的标记点位置
    if (allData.value.markers && allData.value.markers[waypointIndex]) {
      const marker = allData.value.markers[waypointIndex];
      marker.setPosition([longitude, latitude]);

      // 更新标记点的扩展数据
      const extData = marker.getExtData();
      extData.originalPosition = [longitude, latitude];
      marker.setExtData(extData);

      // 重新渲染标记点高度
      render_marker_height(marker);
    }
    if (allData.value.groundMarkers && allData.value.groundMarkers[waypointIndex]) {
      const marker = allData.value.groundMarkers[waypointIndex];
      marker.setPosition([longitude, latitude]);
      // 更新标记点的扩展数据
      const extData = marker.getExtData();
      extData.originalPosition = [longitude, latitude];
      marker.setExtData(extData);
    }
    // 重新渲染图层
    RenderinglineLayer();
    RenderingguideLineLayer();
    // 更新距离标签
    updateDistanceLabels();
    // 重新计算总距离
    calculateTotalDistance();

    // 重新构建线段数据
    // rebuildLineData();
    // console.log("更新数据12", allData.value);
    // emit("allData", allData.value);
    emit("totalDistance", totalDistance.value);
    emit("waypointCoordinateUpdated", {
      waypointIndex,
      longitude,
      latitude,
      height: originalHeight,
    });
  } catch (error) {
    console.error("更新航点坐标时出错:", error);
  }
};
// 更新标记点提示框中的高度信息
const updateMarkerTooltipHeight = (marker, newHeight) => {
  const markerElement = marker.getContent();

  // 如果返回的是字符串，需要先转换为DOM元素
  let domElement = null;
  if (typeof markerElement === "string") {
    // 创建临时容器来解析HTML字符串
    const tempDiv = document.createElement("div");
    tempDiv.innerHTML = markerElement;
    domElement = tempDiv.firstElementChild;
  } else if (
    markerElement &&
    typeof markerElement.querySelector === "function"
  ) {
    domElement = markerElement;
  }

  if (domElement) {
    // 在当前标记点内查找对应的提示框
    const tooltipElement = domElement.querySelector(".line-tooltip");
    if (tooltipElement) {
      // 更新提示框中的高度信息
      const aslElement = tooltipElement.querySelector("div:first-child");
      const haeElement = tooltipElement.querySelector("div:last-child");

      if (aslElement) {
        aslElement.textContent = `ASL: ${newHeight}m`;
      }
      if (haeElement) {
        haeElement.textContent = `HAE: ${newHeight}m`;
      }

      // 更新标记点内容
      marker.setContent(domElement.outerHTML);
    }
  }
};
// 局部更新函数
// const updateSingleLine = (extData, newCoords) => {
//   if (allData.value.length === 0) return;

//   // 判断是起飞点线段还是航线线段
//   if (extData.index == -1) {
//     startdata.lineData.geometry.coordinates = newCoords; // 更新起飞点连接线
//   } else {
//     allData.value.lineData[extData.index].geometry.coordinates = newCoords; // 更新航线线段
//   }

//   // 仅更新特定线段而不是整个图层
//   lineLayer.getSource().setData({
//     type: "FeatureCollection",
//     features: getMergedLineFeatures(),
//   });
//   lineLayer.render();
// };
// 计算整数化倍数：
const integerOperation = (val1, val2) => {
  // 添加参数验证
  if (
    val1 === undefined ||
    val1 === null ||
    val2 === undefined ||
    val2 === null
  ) {
    console.error("integerOperation: 参数不能为undefined或null", {
      val1,
      val2,
    });
    return 1; // 返回默认值
  }

  const val1DecimalIndex = val1.toString().indexOf("."); // 获取数值1的小数位的长度
  const len1 =
    val1DecimalIndex === -1 ? 0 : val1.toString().length - val1DecimalIndex - 1;
  const val2DecimalIndex = val2.toString().indexOf("."); // 获取数值2的小数位的长度
  const len2 =
    val2DecimalIndex === -1 ? 0 : val2.toString().length - val2DecimalIndex - 1;
  const p = Math.max(len1, len2); // 获取大的小数位数
  return Math.pow(10, p); // Math.pow() 计算一个数的指定次幂的方法 10的p次方
};
// 解决浮点数运算的精度
const arithmetic = {
  add (val1, val2) {
    const p = integerOperation(val1, val2);
    return (val1 * p + val2 * p) / p;
  },
  subtract (val1, val2) {
    const p = integerOperation(val1, val2);
    return (val1 * p - val2 * p) / p;
  },
  multiply (val1, val2) {
    const p = integerOperation(val1, val2);
    return (val1 * p * (val2 * p)) / (p * p);
  },
  division (val1, val2) {
    const p = integerOperation(val1, val2);
    return (val1 * p) / (val2 * p) / (p * p);
  },
};
const rotation = ref(0)
// 监听地图视图变化
const initRotationListeners = () => {
  if (!map.value) return;
  // 监听地图视图变化
  map.value.on("viewchange", () => {
    rotation.value = map.value.getRotation() // 更新角度
    previousPitch.value = map.value.getPitch(); // 更新Pitch值 用于右下角图标显示
    // set_map_for_pitch(pitch)
    // 隐藏删除按钮
    if (showDeleteButton.value) {
      hideDeleteButton()
    }
  });
};

const viewsetRotationClick = (num = 'woce') => {
  if (num == 'woce') {
    map.value.setRotation(0, false, 500);
  } else {
    map.value.setRotation(num, true);
  }
}
// 回到地图中心点
const getviewcenterClick = () => {
  map.value.setCenter(defaultCenter);
};
// 实时监听是否是2d视角地图 ==================================================
let is_change_pitch = false;
watch(() => previousPitch.value, (newPitch) => {
  set_map_for_pitch(newPitch)
})
const set_map_for_pitch = (pitch) => {
  if (pitch === 0) {
    // 2d
    is_change_pitch = false;
    set_map_for_pitch_c1(false);
  } else {
    // 3d 因为移动视角多次触发，只执行一次
    if (is_change_pitch) return;
    set_map_for_pitch_c1(true);
    // 设置空中的航点禁止拖动
    is_change_pitch = true;
  }
}
const set_map_for_pitch_c1 = (is3d) => {
  // 空中点
  for (let i in allData.value.markers) {
    if (is3d) {
      allData.value.markers[i].setDraggable(false);
      allData.value.markers[i].off("positionUpdate");
      allData.value.markers[i].on("positionUpdate", function () {
        var altitude = this.getExtData().altitude;
        const newPosition = [
          this.getPosition().lng,
          this.getPosition().lat,
          altitude,
        ];
        this.setPosition(newPosition);
      });
      allData.value.markers[i].emit("positionUpdate");
    } else {
      allData.value.markers[i].setDraggable(true);
      allData.value.markers[i].off("positionUpdate");
      allData.value.markers[i].on("positionUpdate", function () {
        // var altitude = this.getExtData().altitude;
        const newPosition = [
          this.getPosition().lng,
          this.getPosition().lat,
          0,
        ];
        this.setPosition(newPosition);
      });
      allData.value.markers[i].emit("positionUpdate");
    }
  }
  // 地面点是否显示
  for (let i in allData.value.groundMarkers) {
    if (is3d) {
      allData.value.groundMarkers[i].show()
    } else {
      allData.value.groundMarkers[i].hide()
    }
  }
  RenderinglineLayer();
  // 渲染辅助线
  RenderingguideLineLayer();
  updateDistanceLabels();
}
// ==========================================================================
// setDraggable
// 获取地图视角 2d 3d
const getviewClick = (value) => {
  map.value.setPitch(value ? 50 : 0);
  // console.log(value, map.value.getPitch())
  if (map.value.getPitch() == 0) {
    previousPitch.value = map.value.getPitch()
  }
  // 更新当前视图模式状态
  // 根据2D/3D模式控制标点显示和辅助线显示
  return;
  if (!value) {
    // 2D模式：隐藏空中航点，只显示地上航点，隐藏辅助线
    previousPitch.value = 0; // 重置pitch值
    if (allData.value.length > 0) {
      // 隐藏所有空中航点标记
      if (allData.value.markers && allData.value.markers.length > 0) {
        allData.value.markers.forEach((marker) => {
          marker.hide();
        });
      }

      // 显示所有底部圆点marker（地上航点）
      allData.value.groundMarkers.forEach((marker) => {
        if (marker && marker.show) {
          // 2D模式下显示带index的样式
          const extData = marker.getExtData();
          marker.setContent(`<div style="position:relative;">
    <div class="line-tooltip">
      <div>ASL: ${extData.altitude || 0}m</div>
      <div>HAE: ${extData.altitude || 0}m</div>
    </div>
    <div class="marker-index">${extData.index === -1 ? "T" : extData.index + 1
            }</div> </div>`);
          marker.setOffset(new AMap.Pixel(-15, -15));

          // 添加tooltip功能
          addMarkerTooltip(marker, "航点");

          // 添加双击事件 - 2D模式下重新添加双击事件
          marker.on("dblclick", (e) => {
            // 双击事件 - 将航点数据传给父元素
            const position = marker.getPosition();
            const waypointData = {
              lng: position.lng,
              lat: position.lat,
              altitude: allData.value.points[extData.index]
                ? allData.value.points[extData.index][2]
                : 0,
              index: extData.index,
            };

            // 发送给父组件
            emit("waypointDoubleClick", waypointData);
          });

          // 添加右键删除事件
          marker.on("rightclick", (e) => {
            showDeleteButtonHandler(e, extData.index);
          });

          marker.show();
        }
      });
    }

    // 隐藏辅助线图层
    if (window.guideLineLayer) {
      window.guideLineLayer.hide();
    }

    // 重新绘制连接线，使用地上坐标（高度为0）
    updateLineHeightFor2D();

    // 重新更新距离标签，2D模式下高度为0
    updateDistanceLabels();
  } else {
    // 3D模式：显示空中航点，隐藏地上航点，显示辅助线
    previousPitch.value = map.value.getPitch(); // 记录3D模式的pitch值
    if (allData.value.length > 0) {
      // 显示所有空中航点标记
      if (allData.value.markers && allData.value.markers.length > 0) {
        allData.value.markers.forEach((marker) => {
          marker.show();
        });
      }

      // 显示起飞点标记
      if (startdata && startdata.marker) {
        startdata.marker.show();
      }

      // 隐藏所有底部圆点marker
      allData.value.groundMarkers.forEach((marker) => {
        if (marker && marker.hide) {
          // 3D模式下恢复简单圆点样式
          marker.setContent(
            `<div style="width:8px;height:8px;background:#f0ed7a;border-radius:50%;border:1px solid #fff;"></div>`
          );
          marker.setOffset(new AMap.Pixel(-4, -8));
          marker.hide();
        }
      });
    }

    // 显示辅助线图层
    if (window.guideLineLayer) {
      window.guideLineLayer.show();
    }

    // 重新绘制连接线，使用真实高度
    updateLineHeightFor3D();

    // 重新更新距离标签，3D模式下使用真实高度
    updateDistanceLabels();
  }
};
// 获取地图尺寸
const getmapsizeClick = (operation) => {
  if (map.value) {
    let currentZoom = map.value.getZoom(); // 获取当前地图缩放级别
    const zoomChange = operation === "add" ? 0.1 : -0.1; // 每次点击缩放变化量，可根据需要调整
    map.value.setZoomAndCenter(currentZoom + zoomChange, map.value.getCenter()); // 设置新的缩放级别，同时保持当前地图中心不变
  }
};
// 检查图层是否存在的辅助函数
const hasLayer = (className) => {
  if (!map.value) return false;
  const layers = map.value.getLayers();
  return layers.some((layer) => layer.CLASS_NAME === className);
};

// 移除指定类型的图层
const removeLayerByType = (className) => {
  if (!map.value) return;
  const layers = map.value.getLayers();
  layers.forEach((layer) => {
    if (layer.CLASS_NAME === className) {
      map.value.remove(layer);
    }
  });
};

// 获取地图类型
const getmapTypeClick = (type) => {
  if (type.type == 1) {
    // 标准地图
    if (!hasLayer("AMap.TileLayer")) {
      map.value.add(new AMap.TileLayer());
      // 设置标准地图的 features
      map.value.setFeatures(["bg", "building", "road", "point"]);
    }
  } else {
    // 移除标准地图图层
    if (hasLayer("AMap.TileLayer")) {
      removeLayerByType("AMap.TileLayer");
    }
    // 卫星地图-天地图
    if (!hasLayer("AMap.TileLayer.Satellite")) {
      map.value.add(satelliteLayer.value);
    }
    if (type.road) {
      if (!hasLayer("AMap.TileLayer.RoadNet")) {
        map.value.add(roadNetLayer.value);
      }
    } else {
      if (hasLayer("AMap.TileLayer.RoadNet")) {
        removeLayerByType("AMap.TileLayer.RoadNet");
      }
    }
  }
};

// 起飞点设置（重设模式）
const enterSetTakeoffMode = () => {
  drawing_mode.value = 1; //起飞点设置
  // isDrawing.value = true;
  // isFirstTimeTakeoff.value = false; // 重设模式不是首次设置
  // isResetMode.value = true; // 标记为重设模式
  map.value.getContainer().style.cursor = "crosshair"; // 设置鼠标样式

  // 禁用双击放大功能，防止在设置起飞点时意外放大地图
  if (map.value) {
    map.value.setStatus({
      doubleClickZoom: false,
    });
  }
  mapviewRef.value.setdrawingMode(false);
};


//绘制默认航线
// const getDrawDefaultRoute = (airlineform) => {
//   let wayPoints = airlineform.wayPoints; //航点
//   let takeOffRefPoint = airlineform.takeOffRefPoint.split(","); //起飞点坐标
//   takeOffRefPoint = [
//     parseFloat(takeOffRefPoint[0]),
//     parseFloat(takeOffRefPoint[1]),
//   ];
//   let takeOffRefHeight = airlineform.takeOffSecurityHeight; //起飞点高度
//   pointsList.value = wayPoints.map((item) => {
//     return {
//       lng: item.longitude,
//       lat: item.latitude,
//       height: item.height,
//     };
//   });
//   startdata.value.point = takeOffRefPoint;
//   startdata.value.point[2] = takeOffRefHeight;
//   map.value.setCenter(takeOffRefPoint); //设置地图中心点
//   createGroundMarker(wayPoints); //创建航点
//   renderGuideLine(wayPoints); //渲染辅助线
// };
// // 创建标记映射表
// const groundMarkerMap = ref(new Map()); // 存储 index -> 地面标记 的映射
// const flightMarkerMap = ref(new Map()); // 存储 index -> 空中标记 的映射
// //传入经纬度转换为数字
const lnglatToNumber = (lng, lat) => {
  return [Number(lng.toFixed(12)), Number(lat.toFixed(12))];
};
// //数据渲染航点
// const createGroundMarker = (wayPoints) => {
//   //如果是编辑
//   if (route.query.id) {
//     wayPoints.forEach((item, index) => {
//       const marker = new AMap.Marker({
//         position: [item.longitude, item.latitude, 0],
//         content: `<div class="ground-marker"></div>`,
//         offset: new AMap.Pixel(0, 0),
//         draggable: true, //启用拖拽
//         extData: {
//           altitude: 0, // 起飞点标记保持在地面
//           index: index,
//           originalPosition: [item.longitude, item.latitude, 0],
//         },
//       });
//       const markerFlay = new AMap.Marker({
//         position: [item.longitude, item.latitude, item.height],
//         content: `<div class="ground-marker-flay">${index + 1}</div>`,
//         offset: new AMap.Pixel(0, 0),
//         // draggable: true, //启用拖拽
//         extData: {
//           altitude: item.height, // 空中航点高度
//           index: index,
//           originalPosition: [item.longitude, item.latitude, item.height],
//         },
//       });
//       // 保存映射关系
//       groundMarkerMap.value.set(index, marker);
//       flightMarkerMap.value.set(index, markerFlay);
//       map.value.add(marker);
//       map.value.add(markerFlay);
//       groundMarkerDrag(marker); //拖拽航点
//       // airMarkerDrag(markerFlay); //拖拽航点
//     });
//   }
// };

// //地下航点拖拽
// const groundMarkerDrag = (marker) => {
//   //鼠标变move mouseover 鼠标移入
//   marker.on("mouseover", (e) => {
//     if (map.value) {
//       map.value.getContainer().style.cursor = "move";
//     }
//   });
//   marker.on("mouseout", (e) => {
//     if (map.value) {
//       map.value.getContainer().style.cursor = "default";
//     }
//   });
//   marker.on("dragging", (e) => {
//     if (map.value) {
//       map.value.getContainer().style.cursor = "move";
//     }
//     updateDragData(marker, e, "ground");
//   });
//   marker.on("dragend", (e) => {
//     if (map.value) {
//       map.value.getContainer().style.cursor = "default";
//     }
//     // marker.off("dragging");
//   });
// };
// //更新拖拽数据
// const updateDragData = (marker, e, type) => {
//   //更新航点坐标
//   const extData = marker.getExtData();
//   const newPosition = lnglatToNumber(e.lnglat.KL, e.lnglat.kT);
//   extData.originalPosition = [newPosition[0], newPosition[1], 0];
//   marker.setExtData(extData);

//   // 更新 pointsList 中对应索引的坐标
//   if (extData.index !== undefined && extData.index >= 0) {
//     pointsList.value[extData.index] = {
//       ...pointsList.value[extData.index],
//       lng: newPosition[0],
//       lat: newPosition[1],
//     };

//     const flightMarker = flightMarkerMap.value.get(extData.index);
//     if (flightMarker) {
//       const height = pointsList.value[extData.index].height || 0;
//       flightMarker.setPosition([newPosition[0], newPosition[1], height]);
//     }
//   }
// };
// //渲染辅助线
// const renderGuideLine = (wayPoints) => {
//   if (route.query.id) {
//     wayPoints.forEach((item, index) => {
//       const guideLine = new AMap.Polyline({
//         path: [
//           [item.longitude, item.latitude, 0],
//           [item.longitude, item.latitude, item.height],
//         ],
//         strokeColor: "#00d58f",
//         strokeWeight: 2,
//       });
//       map.value.add(guideLine);
//     });
//   }
// };
// 起飞点提示显示逻辑
// const shouldShowTakeoffTip = computed(() => {
//   // 有起飞点就不显示
//   if (isResetMode.value) {
//     return false;
//   }

//   // 检查是否有起飞点数据（包括默认数据）
//   const hasTakeoffPoint =
//     startdata?.point &&
//     startdata?.point.length > 0;
//   const hasTakeoffMarker = startdata?.marker;

//   // 检查是否有航点数据
//   const hasWaypoints = allData.value?.points && allData.value?.points.length > 0;

//   // 如果已经有起飞点或航点，不显示提示
//   if (hasTakeoffPoint || hasTakeoffMarker || hasWaypoints) {
//     return false;
//   }

//   // 对于编辑航线的情况，即使有默认数据，如果还没有设置起飞点，也应该显示提示
//   if (props.drawDefaultRoute && props.drawDefaultRoute.length > 0) {
//     // 检查默认数据中是否有起飞点
//     const defaultRoute = props.drawDefaultRoute[0];
//     const hasDefaultTakeoffPoint = defaultRoute?.startdata?.point &&
//       defaultRoute.startdata.point.length > 0;

//     // 如果默认数据中没有起飞点，则显示提示
//     return !hasDefaultTakeoffPoint;
//   }

//   // 默认情况下，如果没有起飞点和航点，显示提示
//   return true;
// });
// 监听起飞点提示的显示状态，自动开启地图点击事件
// watch(shouldShowTakeoffTip, (newVal) => {
//   // 在重设模式下，不执行任何操作
//   if (isResetMode.value) {
//     return;
//   }

//   // 如果正在退出首次设置模式，不执行任何操作
//   if (isExitingFirstTimeMode.value) {
//     return;
//   }

//   // 如果已经不是首次设置起飞点，不执行任何操作
//   if (!isFirstTimeTakeoff.value) {
//     return;
//   }

//   // 如果有默认数据，不启用绘制模式
//   if (props.drawDefaultRoute && props.drawDefaultRoute.length > 0) {
//     return;
//   }

//   // 如果用户已经手动设置了绘制状态，不要自动修改
//   // if (hasUserInteracted.value) {
//   //   return;
//   // }

//   if (newVal && map.value) {
//     // 显示提示时，设置 isDrawing = true 和 drawing_mode = 2
//     // 这样既可以绘制航点，也可以设置起飞点


//     // isDrawing.value = true;
//     drawing_mode.value = 2; // 起飞点设置模式
//     map.value.getContainer().style.cursor = "crosshair";

//     // 确保添加起飞点点击监听器
//     map.value.off("click", handleMapClickForTakeoff);
//     map.value.on("click", handleMapClickForTakeoff);
//   } else if (!newVal && map.value) {
//     // 隐藏提示时，恢复默认状态（仅在没有默认数据时）
//     if (!props.drawDefaultRoute || props.drawDefaultRoute.length === 0) {
//       // isDrawing.value = false;
//       drawing_mode.value = 1; // 重置为航线绘制模式
//       map.value.getContainer().style.cursor = "default";
//       map.value.off("click", handleMapClickForTakeoff);
//     }
//   }
// });

// 退出"设置起飞点"模式
const exitSetTakeoffMode = () => {
  // 只有在非重设模式下才发送事件（避免重复发送）
  // if (props.flayShow !== false) {
  //   emit("delSetTakeoffMode", true);
  // }
  // isDrawing.value = false;
  drawing_mode.value = 3; // 重置为航线绘制模式
  // isResetMode.value = false; // 退出重设模式

  // 恢复双击放大功能
  // if (map.value) {
  //   map.value.setStatus({
  //     doubleClickZoom: true,
  //   });
  // }

  map.value.getContainer().style.cursor = "default"; // 恢复鼠标样式
  // map.value.off("click", handleMapClickForTakeoff); // 移除地图点击监听
};
// 监听起飞点高度变化
// watch(
//   () => props.flightaltitude,
//   (newVal, oldVal) => {
//     // 保存旧的高度模式
//     const oldMode = previousHeightMode.value;
//     // 更新之前的高度模式
//     previousHeightMode.value = newVal;
//     // 更新默认高度
//     setDefaultHeightByMode();
//     // 更新现有航点的高度，传入旧的高度模式
//     updateExistingPointsHeight(oldMode);
//   }
// );
// 监听安全起飞高度变化
// watch(
//   () => props.safetakeoffaltitude,
//   (newVal, oldVal) => {
//     // 更新现有起飞点的高度
//     if (
//       allData.value.length > 0 &&
//       startdata &&
//       startdata.point
//     ) {
//       // 更新起飞点高度

//       startdata.point[2] = newVal;
//       // 更新起飞点标记的高度显示
//       if (startdata.marker) {
//         const extData = startdata.marker.getExtData();
//         extData.altitude = 0; // 起飞点标记保持在地面
//         startdata.marker.setExtData(extData);
//         render_marker_height(startdata.marker);
//       }

//       // 更新起飞点辅助线
//       if (startdata.guideLineData) {
//         // 对于Point类型，更新高度属性
//         startdata.guideLineData.properties.h = newVal;
//       }

//       // 重新构建线段数据
//       rebuildLineData();
//       // 更新距离标签
//       clearDistanceMarkers();
//       updateDistanceLabels();
//       // 重新计算总距离
//       calculateTotalDistance();
//       // 通知父组件数据更新
//       // console.log("更新数据14", allData.value);
//       emit("allData", allData.value);
//       emit("totalDistance", totalDistance.value);
//       // 重新渲染
//       RenderinglineLayer();
//       RenderingguideLineLayer();
//     } else {
//     }
//   }
// );

// 监听默认航线数据变化
// watch(
//   () => props.drawDefaultRoute,
//   (newVal, oldVal) => {
//     if (newVal && newVal[0] && isMapInitialized.value) {
//       // 检查是否有航点数据或起飞点数据
//       const hasPoints = (newVal[0].points && newVal[0].points.length > 0) ||
//         (newVal[0].point && newVal[0].point.length > 0);
//       const hasTakeoffPoint = newVal[0].startdata && newVal[0].startdata.point &&
//         newVal[0].startdata.point.length > 0;

//       // 只有在有数据的情况下才绘制
//       if (hasPoints || hasTakeoffPoint) {
//         // 确保地图完全加载后再绘制
//         setTimeout(() => {
//           drawDefaultRoute(newVal[0]);
//         }, 500);
//       }
//     }
//   },
//   { immediate: false } // 不要立即执行，等待地图初始化完成
// );

// 防抖定时器
// let airlineListUpdateTimer = null;
// 添加数据更新防抖定时器
// let dataUpdateDebounceTimer = null;
// const DATA_UPDATE_DEBOUNCE_DELAY = 300; // 300ms防抖延迟

// 监听航点列表变化，更新地图上的航点高度
// watch(
//   () => props.airlineList,
//   (newVal, oldVal) => {
//     // 如果有默认数据且不在绘制模式下，只允许高度更新，不允许其他更新
//     if (
//       props.drawDefaultRoute &&
//       props.drawDefaultRoute.length > 0 &&
//       drawing_mode.value == 3
//     ) {
//       // 检查是否只是高度变化，如果是则允许更新
//       let hasHeightChanges = false;
//       if (oldVal && newVal && oldVal.length === newVal.length) {
//         for (let i = 0; i < newVal.length; i++) {
//           if (oldVal[i] && newVal[i] && oldVal[i].height !== newVal[i].height) {
//             hasHeightChanges = true;
//             break;
//           }
//         }
//       }

//       if (!hasHeightChanges) {
//         return;
//       }
//     }

//     // 清除之前的定时器
//     if (airlineListUpdateTimer) {
//       clearTimeout(airlineListUpdateTimer);
//     }

//     // 设置防抖延迟
//     airlineListUpdateTimer = setTimeout(() => {
//       if (
//         allData.value.length > 0 &&
//         allData.value.points &&
//         allData.value.points.length > 0 &&
//         newVal &&
//         newVal.length > 0
//       ) {
//         let hasChanges = false;

//         // 更新每个航点的高度
//         newVal.forEach((waypoint, index) => {
//           if (index < allData.value.points.length) {
//             const oldHeight = allData.value.points[index][2];
//             const newHeight = waypoint.height || 0;

//             if (oldHeight !== newHeight) {
//               // 更新航点坐标的高度（真实数据）
//               allData.value.points[index][2] = newHeight;

//               // 更新对应标记点的高度显示
//               if (allData.value.markers && allData.value.markers[index]) {
//                 const marker = allData.value.markers[index];
//                 const extData = marker.getExtData();
//                 extData.altitude = newHeight;
//                 marker.setExtData(extData);
//                 render_marker_height(marker);
//               }

//               hasChanges = true;
//             }
//           }
//         });

//         // 只有在有实际变化时才更新地图
//         if (hasChanges) {
//           // 更新距离标签
//           clearDistanceMarkers();
//           updateDistanceLabels();
//           // 重新计算总距离
//           calculateTotalDistance();

//           // 根据当前视图模式重新渲染
//           if (previousPitch.value != 0) {
//             // 3D模式：使用真实高度
//             rebuildLineData();
//             RenderinglineLayer();
//             RenderingguideLineLayer();
//           } else {
//             // 2D模式：使用地上坐标
//             updateLineHeightFor2D();
//             // 隐藏辅助线
//             if (window.guideLineLayer) {
//               window.guideLineLayer.hide();
//             }
//           }
//         }
//       }
//     }, 100); // 100ms 防抖延迟
//   },
//   { deep: true } // 深度监听，监听数组内部对象的变化
// );

// 专门监听航点高度变化的监听器
// watch(
//   () => props.airlineList?.map((wp) => wp.height),
//   (newHeights, oldHeights) => {
//     // 如果有高度变化，强制更新地图
//     if (
//       newHeights &&
//       oldHeights &&
//       JSON.stringify(newHeights) !== JSON.stringify(oldHeights)
//     ) {
//       // 延迟执行，确保其他更新完成
//       setTimeout(() => {
//         if (allData.value.length > 0 && allData.value.points) {
//           newHeights.forEach((height, index) => {
//             if (
//               index < allData.value.points.length &&
//               height !== undefined
//             ) {
//               const oldHeight = allData.value.points[index][2];
//               if (oldHeight !== height) {
//                 allData.value.points[index][2] = height;

//                 // 更新对应标记点的高度显示
//                 if (
//                   allData.value.markers &&
//                   allData.value.markers[index]
//                 ) {
//                   const marker = allData.value.markers[index];
//                   const extData = marker.getExtData();
//                   extData.altitude = height;
//                   marker.setExtData(extData);
//                   render_marker_height(marker);
//                 }
//               }
//             }
//           });

//           // 重新渲染地图
//           if (previousPitch.value != 0) {
//             rebuildLineData();
//             RenderinglineLayer();
//             RenderingguideLineLayer();
//           } else {
//             updateLineHeightFor2D();
//           }
//         }
//       }, 200);
//     }
//   },
//   { deep: true }
// );
//监听航线表单变化
// watch(
//   () => props.airlineform,
//   (newVal, oldVal) => {
//     if (newVal) {
//       console.log("航线表单", newVal);
//       getDrawDefaultRoute(newVal);
//     }
//   }
// );
// 获取详情默认数据
const getdrawDefaultRoute = (data) => {
  setTimeout(() => {
    if (data.takeOffRefPoint) {
      const point = data.takeOffRefPoint.split(',')
      handleMapClickForTakeoff([parseFloat(point[0]), parseFloat(point[1])], parseFloat(point[2]), false);
      // 起飞点
      is_has_takeOffRefPoint.value = true;
      getmouseDrawClick();
    }
    // console.log(data.wayPoints)
    if (data.wayPoints.length > 0) {
      let points = [];
      for (let i in data.wayPoints) {
        let item = data.wayPoints[i]
        points.push([parseFloat(item.longitude), parseFloat(item.latitude), parseFloat(item.height)])
        addMarker([parseFloat(item.longitude), parseFloat(item.latitude), parseFloat(item.height)], i, false);
      }
      allData.value.points = points
      RenderinglineLayer();
      RenderingguideLineLayer();
      updateDistanceLabels();
      // emit("allData", allData.value);
    }
    calculateTotalDistance();
    map.value.setFitView();
  }, 800);
}
// 生命周期
onMounted(async () => {
  await initMap(); // 初始化地图
  // 如果编辑航线，则设置加载状态
  // if (route.query.id) {
  //   isLoadingDefaultRoute.value = true;
  // }
  // 初始化之前的高度模式
  // previousHeightMode.value = props.flightaltitude;
  // 根据高度模式设置默认高度
  // setDefaultHeightByMode();

  // 地图初始化完成后，如果有默认航线数据，触发绘制
  // if (props.drawDefaultRoute &&
  //   props.drawDefaultRoute &&
  //   ((props.drawDefaultRoute.points && props.drawDefaultRoute.points.length > 0) ||
  //     (props.drawDefaultRoute.point && props.drawDefaultRoute.point.length > 0))) {
  //   isLoadingDefaultRoute.value = true;
  //   // 等待地图初始化完成后再绘制
  //   const checkAndDraw = () => {
  //     if (isMapInitialized.value) {
  //       drawDefaultRoute(props.drawDefaultRoute[0]);
  //     } else {
  //       setTimeout(checkAndDraw, 100);
  //     }
  //   };
  //   setTimeout(checkAndDraw, 500);
  // }

  // 地图初始化完成后，手动检查是否需要显示起飞点提示
  // 使用 nextTick 确保 DOM 更新完成
  // nextTick(() => {
  //   if (shouldShowTakeoffTip.value && map.value) {
  //     // isDrawing.value = true;
  //     drawing_mode.value = 1; // 起飞点设置模式
  //     map.value.getContainer().style.cursor = "crosshair";

  //     // 确保添加起飞点点击监听器
  //     // map.value.off("click", handleMapClickForTakeoff);
  //     // map.value.on("click", handleMapClickForTakeoff);
  //   }
  // });

  // 添加点击其他地方隐藏删除按钮的事件
  // document.addEventListener("click", (e) => {
  //   if (!e.target.closest(".delete-button")) {
  //     hideDeleteButton();
  //   }
  // });
  // 添加鼠标按下事件，如果鼠标不在删除按钮上就隐藏删除按钮
  // document.addEventListener("mousedown", (e) => {
  //   if (!e.target.closest(".delete-button")) {
  //     hideDeleteButton();
  //   }
  // });
});

onBeforeUnmount(() => {
  // 清理地图
  window.removeEventListener("keydown", handleKeyDown);
  window.removeEventListener("keyup", handleKeyUp);
  document.removeEventListener('visibilitychange', hvisibilitychange)
  window.removeEventListener('blur', hvisibilityblur);
  if (map.value) {
    // 重置鼠标光标样式
    map.value.getContainer().style.cursor = "default";
    map.value.destroy();
  }
  if (window.airportMarkers && window.airportMarkers.length > 0) {
    window.airportMarkers.forEach((marker) => {
      if (map.value) {
        map.value.remove(marker);
      }
    });
    window.airportMarkers = [];
  }

  // 清理事件监听
  // window.removeEventListener("keydown", handleKeyDown);
  // window.removeEventListener("keyup", handleKeyUp);

  // 清理 AMap 事件监听器
  // if (autoComplete.value) {
  //   autoComplete.value.off("select", selectHandler);
  // }

  // if (placeSearch.value) {
  //   placeSearch.value.off("markerClick", clickMarkerHandler);
  // }
});

// 根据高度模式设置默认高度
// const setDefaultHeightByMode = () => {
//   // 现在 flightaltitude 是具体的数值，直接使用
//   defaultHeight = props.flightaltitude || 300; // 使用传入的高度值，默认300米
// };

// 更新现有航点的高度 - 基于差值调整而不是直接覆盖
// const updateExistingPointsHeight = (oldHeightMode) => {
//   if (allData.value.point.length === 0) return;
//   // 获取旧的高度模式对应的默认高度
//   const getOldDefaultHeight = (oldMode) => {
//     // 现在 oldMode 是具体的数值，直接返回
//     return oldMode || 300;
//   };
//   // 计算高度差值
//   const oldDefaultHeight = getOldDefaultHeight(oldHeightMode);
//   const heightDiff = defaultHeight - oldDefaultHeight;

//   // 更新起飞点高度 - 起飞点始终使用新的默认高度
//   if (startdata.point && startdata.point.length > 0) {
//     // 只有当没有设置安全起飞高度时，才使用默认高度
//     if (!props.safetakeoffaltitude || props.safetakeoffaltitude <= 0) {
//       startdata.point[2] = defaultHeight;
//     } else {
//       // 如果设置了安全起飞高度，保持使用安全起飞高度
//       startdata.point[2] = props.safetakeoffaltitude;
//     }

//     // 更新起飞点标记的高度显示
//     if (startdata.marker) {
//       const extData = startdata.marker.getExtData();
//       extData.altitude = 0; // 起飞点标记保持在地面
//       startdata.marker.setExtData(extData);
//       render_marker_height(startdata.marker);
//     }
//   }

//   // 遍历所有航点，基于差值调整高度
//   if (allData.value.points && allData.value.points.length > 0) {
//     allData.value.points.forEach((point, index) => {
//       // 检查该航点是否跟随航线高度（heightFollow为1表示跟随）
//       // 只有当heightFollow为1时才更新高度
//       const heightFollow = props.airlineList && props.airlineList[index] ?
//         props.airlineList[index].heightFollow : 1; // 默认为1（跟随）

//       if (heightFollow === 1) {
//         // 获取当前航点的高度
//         const currentHeight = point[2] || oldDefaultHeight;

//         // 计算航点相对于默认高度的差值
//         const pointDiff = currentHeight - oldDefaultHeight;

//         // 新高度 = 新默认高度 + 航点原有的差值
//         const newHeight = defaultHeight + pointDiff;

//         // 更新航点高度
//         point[2] = newHeight;

//         // 更新对应标记点的高度显示
//         if (allData.value.markers && allData.value.markers[index]) {
//           const marker = allData.value.markers[index];
//           const extData = marker.getExtData();
//           extData.altitude = newHeight;
//           marker.setExtData(extData);
//           render_marker_height(marker);
//         }
//       }
//       // 如果heightFollow不为1，则不处理该航点的高度
//     });
//   }

//   // 重新构建线段数据
//   rebuildLineData();
//   // 更新距离标签
//   clearDistanceMarkers();
//   updateDistanceLabels();
//   // 重新计算总距离
//   calculateTotalDistance();
//   // 通知父组件数据更新
//   // console.log("更新数据15", allData.value);
//   // emit("allData", allData.value);
//   emit("totalDistance", totalDistance.value);

//   // 重新渲染
//   RenderinglineLayer();
//   RenderingguideLineLayer();
// };

// 辅助函数：根据索引查找标记
const findMarkerByIndex = (index) => {
  if (!allData.value || !allData.value.points.length > 0) return null;
  // 查找航点数据
  const waypointData = allData.value.markers.find(
    (item, idx) => idx === index
  );
  if (!waypointData) return null;
  if (allData.value.markers && allData.value.markers[index]) {
    return allData.value.markers[index];
  }
  return null;
};

//监听选中航点
watch(
  () => props.selectedWayPoint,
  (newVal, oldVal) => {
    if (oldVal && allData.value && allData.value.points.length > 0) {
      // 查找对应的航点标记
      const oldMarker = findMarkerByIndex(oldVal.index);
      if (oldMarker) {
        // 恢复默认样式 - 直接设置新的 HTML 内容
        const defaultContent = `
          <div style="position:relative;">
            <div class="line-tooltip">
              <div>ASL: ${oldVal.altitude || 0}m</div>
              <div>HAE: ${oldVal.altitude || 0}m</div>
            </div>
            <div class="marker-index">${oldVal.index + 1}</div>
          </div>
        `;
        oldMarker.setContent(defaultContent);
      }
    }
    // 设置新选中航点的颜色为蓝色
    if (newVal && allData.value && allData.value.points.length > 0) {
      const newMarker = findMarkerByIndex(newVal.index);
      if (newMarker) {
        // 创建带有蓝色背景的新内容
        const selectedContent = `
          <div style="position:relative;">
            <div class="line-tooltip">
              <div>ASL: ${newVal.altitude || 0}m</div>
              <div>HAE: ${newVal.altitude || 0}m</div>
            </div>
            <div class="marker-index" style="background-color: #2f69eb; color: #ffffff; border: 2px solid #ffffff;">${newVal.index + 1
          }</div>
          </div>
        `;
        // 设置新的内容
        newMarker.setContent(selectedContent);
        // 可选：将地图中心移动到选中的航点
        const markerPosition = newMarker.getPosition();
        // if (markerPosition) {
        //   map.value.setCenter(markerPosition);
        //   map.value.setZoom(18);
        // }
      }
    }
  }
);
// 搜索
const getsearchClick = (val) => {
  if (!val) return;
  tipInput.value = val;
  let center = map.value.getCenter()
  // let radius = (21 - map.value.getZoom()) * 1000;
  let radius = 50000;

  // console.log(center);
  // console.log(radius)
  // var circle = new AMap.Circle({
  //   center: center,
  //   radius: radius, //半径
  //   borderWeight: 3,
  //   strokeColor: "#FF33FF",
  //   strokeOpacity: 1,
  //   strokeWeight: 6,
  //   strokeOpacity: 0.2,
  //   fillOpacity: 0.4,
  //   strokeStyle: 'dashed',
  //   strokeDasharray: [10, 10],
  //   // 线样式还支持 'dashed'
  //   fillColor: '#1791fc',
  //   zIndex: 50,
  // })
  placeSearch.value.search(tipInput.value, (status, result) => {
    if (status === "complete" && result.poiList?.pois) {
      address.value = result.poiList.pois;
      mapviewRef.value.updateSearchInfo(address.value);
      if (address.value.length === 0) {
        ElMessage.info("未找到相关地点");
      } else {
        handleSearchResults(result.poiList.pois);
      }
    } else {
      const errorMsg = result?.info || "搜索失败";
      ElMessage.error(errorMsg);
      console.error("搜索出错:", errorMsg);
      address.value = [];
    }
  });
};
const handleSearchResults = (pois) => {
  // 清除之前的搜索标记
  clearClick();

  // 遍历并创建新标记
  pois.forEach(poi => {
    // 创建自定义内容，模拟默认样式
    const content = document.createElement('div');
    content.innerHTML = `
      <div style="
        background-color: #FF552E; 
        width: 28px; 
        height: 28px; 
        border: 2px solid white; 
        border-radius: 14px; 
        box-shadow: 0 2px 4px rgba(0,0,0,0.3);
        display: flex;
        align-items: center;
        justify-content: center;
      ">
        <svg width="14" height="14" viewBox="0 0 24 24" fill="white">
          <path d="M12 2C8.13 2 5 5.13 5 9c0 5.25 7 13 7 13s7-7.75 7-13c0-3.87-3.13-7-7-7zm0 9.5a2.5 2.5 0 0 1 0-5 2.5 2.5 0 0 1 0 5z"/>
        </svg>
      </div>
    `;

    // 创建标记
    const marker = new AMap.Marker({
      position: new AMap.LngLat(poi.location.lng, poi.location.lat), // 标记位置[citation:2]
      content: content, // 使用自定义内容
      offset: new AMap.Pixel(-14, -14), // 偏移，使标记底部中心对准坐标点
      title: poi.name, // 标题[citation:2]
      zIndex: 5,
      map: window.map // 你的地图实例，假设已挂载到window.map
    });
    // 存储标记以便后续管理
    searchMarkers.value.push(marker);
  });
  map.value.add(searchMarkers.value)
}
// const clearClick = () => {
//   map.value.clearMap();
//   map.value.clearInfoWindow();
//   // RenderinglineLayer();
//   // RenderingguideLineLayer();
//   // updateDistanceLabels();
//   if (startdata.value.point.length > 0) {
//     const lnglat = startdata.value.point
//     // handleMapClickForTakeoff([point[0], point[1]], point[2]);
//     if (startdata.value.marker) {
//       map.value.remove(startdata.value.marker);
//       startdata.value.marker = null;
//     }
//     // 创建起飞点标记
//     const t_extData = {
//       altitude: 0, // 起飞点标记保持在地面
//       index: -1,
//       originalPosition: [lnglat[0], lnglat[1]],
//     }
//     const takeoffMarker = new AMap.Marker({
//       position: [lnglat[0], lnglat[1]],
//       content: `<div style="display:flex;align-items:center;justify-content:center;width:30px;height:30px;font-weight:bold;color:white;background:#fff;border-radius:50%;"><img style="width:30px;height:30px" src="/static/flay.png" /></div>`,
//       offset: new AMap.Pixel(-15, -15),
//       extData: t_extData,
//       draggable: true,
//     });
//     map.value.add(takeoffMarker);
//     startdata.value.marker = takeoffMarker
//     // 渲染高度
//     render_marker_height(takeoffMarker);
//     // 添加起飞点鼠标悬停事件 - 显示拖动光标
//     takeoffMarker.on("mouseover", (e) => {
//       if (map.value) {
//         map.value.getContainer().style.cursor = "move";
//       }
//     });

//     takeoffMarker.on("mouseout", (e) => {
//       if (map.value) {
//         // 恢复默认光标样式
//         if (drawing_mode.value != 3) {
//           map.value.getContainer().style.cursor = "crosshair";
//         } else {
//           map.value.getContainer().style.cursor = "default"
//         }
//       }
//     });
//     // 添加起飞点拖动事件
//     takeoffMarker.on("dragstart", (e) => {
//       // 拖动开始时设置光标为move
//       if (map.value) {
//         map.value.getContainer().style.cursor = "move";
//       }
//     });

//     takeoffMarker.on("dragging", (e) => {
//       const extData = takeoffMarker.getExtData();
//       const newPosition = lnglatToNumber(e.lnglat.KL, e.lnglat.kT);
//       // 起飞点只支持正常拖动，不支持高度调整
//       extData.originalPosition = [newPosition[0], newPosition[1]];
//       takeoffMarker.setExtData(extData);

//       // 使用安全起飞高度，而不是extData.altitude
//       const takeoffHeight = startdata.value.point[2] || props.safetakeoffaltitude || 300;
//       startdata.value.point = [
//         newPosition[0],
//         newPosition[1],
//         takeoffHeight,
//       ];
//       // 更新线段和辅助线
//       updateLineAndGuideLine(
//         startdata.value.point,
//         extData
//       );
//       RenderinglineLayer();
//       RenderingguideLineLayer();
//     });

//     takeoffMarker.on("dragend", (e) => {
//       // 拖动结束时恢复光标样式
//       emit("startdata", startdata.value);
//       emit("totalDistance", totalDistance.value);
//     });
//   }
//   if (allData.value.points.length > 0) {
//     allData.value.markers = [];
//     allData.value.groundMarkers = [];
//     for (let i in allData.value.points) {
//       // points.push([parseFloat(item.longitude), parseFloat(item.latitude), parseFloat(item.height)])
//       addMarker(allData.value.points[i], i, false);
//     }
//     // allData.value.points = points
//     RenderinglineLayer();
//     RenderingguideLineLayer();
//     updateDistanceLabels();
//   }
//   map.value.setFitView();
// }
const clearClick = () => {
  map.value.remove(searchMarkers.value);
  searchMarkers.value = [];
  // map.value.setFitView();
}
// 选中搜索结果
const getselectItem = (poi) => {
  const markerPosition = [poi.location.lng, poi.location.lat]; // 地图中心点
  map.value.setCenter(markerPosition);
  map.value.setZoom(16);
};
// 获取机场列表显示在地图上
const set_airportList = (airportList) => {
  if (airportList) {
    airportLists.value = airportList
    if (map.value && airportLists.value.length > 0) {
      createAirportMarker();
    }
  }
}
const getLineHeght = (data) => {
  if (allData.value.points && allData.value.points.length > 0) {
    for (let i in allData.value.points) {
      allData.value.points[i][2] = parseFloat(data[i].height);
      if (allData.value.markers[i]) {
        allData.value.markers[i].setExtData({
          ...allData.value.markers[i].getExtData(),
          altitude: parseFloat(data[i].height),
        });
        updata_marker_height(allData.value.markers[i], parseFloat(data[i].height))
      }
    }
  }
  RenderinglineLayer();
  RenderingguideLineLayer();
  updateDistanceLabels();
}
const getPointHeght = (data) => {
  // console.log(data);
  const i = data.wayPointName
  allData.value.points[i][2] = data.height;
  updata_marker_height(allData.value.markers[i], data.height)//marker位置更新
  RenderinglineLayer(); //航线更新
  RenderingguideLineLayer(); //垂直辅助线更新
  updateDistanceLabels(); //距离标志更新
}
// 起飞点高度
const getTakeOffSecurityHeight = (height) => {
  if (startdata.value.point.length > 0) {
    startdata.value.point[2] = height
    RenderinglineLayer(); //航线更新
    RenderingguideLineLayer(); //垂直辅助线更新
    updateDistanceLabels(); //距离标志更新
  };
}
// 暴露方法给父组件使用
defineExpose({
  set_airportList, //设置机场图标
  updateWaypointCoordinate,// 更新特定航点的坐标
  enterSetTakeoffMode, // 起飞点重设
  exitSetTakeoffMode, // 起飞点取消重设
  getdrawDefaultRoute,//获取详情默认数据
  getLineHeght,//获取航线高度
  getPointHeght,//获取航点高度
  getTakeOffSecurityHeight,//获取航点高度
  computeDis,//计算两个坐标点之间的距离
});

// 清理地图资源
const cleanupMap = () => {
  if (map.value) {
    map.value.destroy();
    map.value = null;
  }
  isMapInitialized.value = false;
  // 清除可能存在的搜索定时器
  if (window.searchTimeout) {
    clearTimeout(window.searchTimeout);
    window.searchTimeout = null;
  }
};

// 组件卸载时清理
onUnmounted(cleanupMap);
</script>
<style lang="scss" scoped>
.takeoff-point {
  position: absolute;
  top: 15%;
  left: 50%;
  width: 60%;
  height: 60px;
  font-size: 12px;
  line-height: 60px;
  color: #fff;
  text-align: center;
  background-color: rgb(0 0 0 / 50%);
  border-radius: 4px;
  transform: translate(-50%, -15%);
}
</style>